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 void DoExport_SuccessExport()
{
//Arrange
var manifest = new PlatformExportManifest();
var fileStream = new FileStream(Path.GetFullPath("export_test.json"), FileMode.Create);
var entityForCount = AbstractTypeFactory <NotificationEntity> .TryCreateInstance(nameof(EmailNotificationEntity));
entityForCount.Id = Guid.NewGuid().ToString();
entityForCount.Type = nameof(EmailNotification);
entityForCount.Kind = nameof(EmailNotification);
_repositoryMock.Setup(r => r.GetByTypeAsync(nameof(RegistrationEmailNotification), null, null, NotificationResponseGroup.Default.ToString())).ReturnsAsync(entityForCount);
var entity = AbstractTypeFactory <NotificationEntity> .TryCreateInstance(nameof(EmailNotificationEntity));
entity.Id = entityForCount.Id;
entity.Type = nameof(EmailNotification);
entity.Kind = nameof(EmailNotification);
entity.Templates = new ObservableCollection <NotificationTemplateEntity>()
{
new NotificationTemplateEntity()
{
Body = "test", LanguageCode = "en-US"
}
};
_repositoryMock.Setup(r => r.GetByTypeAsync(nameof(RegistrationEmailNotification), null, null, NotificationResponseGroup.Full.ToString())).ReturnsAsync(entity);
//Act
_notificationsExportImportManager.ExportAsync(fileStream, null, exportImportProgressInfo => { }, new CancellationTokenWrapper(CancellationToken.None));
//Assert
fileStream.Close();
}
public async Task DoExport_SuccessExport()
{
//Arrange
var manifest = new PlatformExportManifest();
var fileStream = new FileStream(Path.GetFullPath("export_test.json"), FileMode.Create);
var entity = AbstractTypeFactory <Notification> .TryCreateInstance(nameof(EmailNotification));
entity.Id = Guid.NewGuid().ToString();
entity.Type = nameof(RegistrationEmailNotification);
entity.TenantIdentity = new TenantIdentity(Guid.NewGuid().ToString(), nameof(Notification));
entity.Templates = new ObservableCollection <NotificationTemplate>()
{
new EmailNotificationTemplate()
{
Body = "test", LanguageCode = "en-US"
},
};
_notificationSearchServiceMock
.Setup(nss => nss.SearchNotificationsAsync(It.IsAny <NotificationSearchCriteria>()))
.ReturnsAsync(new NotificationSearchResult {
Results = new List <Notification> {
entity
}, TotalCount = 1
});
//Act
await _notificationsExportImportManager.DoExportAsync(fileStream, exportImportProgressInfo => { }, new CancellationTokenWrapper(CancellationToken.None));
//Assert
fileStream.Close();
}
public async Task ExportAsync(Stream outStream, PlatformExportManifest exportOptions, Action <ExportImportProgressInfo> progressCallback, ICancellationToken сancellationToken)
{
if (exportOptions == null)
{
throw new ArgumentNullException(nameof(exportOptions));
}
using (var zipArchive = new ZipArchive(outStream, ZipArchiveMode.Create, true))
{
//Export all selected platform entries
await ExportPlatformEntriesInternalAsync(zipArchive, exportOptions, progressCallback, сancellationToken);
//Export all selected modules
await ExportModulesInternalAsync(zipArchive, exportOptions, progressCallback, сancellationToken);
//Write system information about exported modules
var manifestZipEntry = zipArchive.CreateEntry(ManifestZipEntryName, CompressionLevel.Optimal);
//After all modules exported need write export manifest part
using (var stream = manifestZipEntry.Open())
{
exportOptions.SerializeJson(stream, GetJsonSerializer());
}
}
}
public async Task ImportAsync(Stream stream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback, CancellationToken cancellationToken)
{
if (manifest == null)
{
throw new ArgumentNullException("manifest");
}
var progressInfo = new ExportImportProgressInfo();
progressInfo.Description = "Starting platform import...";
progressCallback(progressInfo);
using (var zipArchive = new ZipArchive(stream))
{
//Import selected platform entries
await ImportPlatformEntriesInternalAsync(zipArchive, manifest, progressCallback, cancellationToken);
//Import selected modules
await ImportModulesInternalAsync(zipArchive, manifest, progressCallback, cancellationToken);
//Reset cache
//TODO:
//_memoryCache.Clear();
}
}
public void Import(Stream stream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
{
if (manifest == null)
{
throw new ArgumentNullException("manifest");
}
var progressInfo = new ExportImportProgressInfo
{
Description = "Starting platform import..."
};
progressCallback(progressInfo);
using (var package = Package.Open(stream, FileMode.Open))
using (var guard = EventSupressor.SupressEvents())
{
//Import selected platform entries
ImportPlatformEntriesInternal(package, manifest, progressCallback);
//Import selected modules
ImportModulesInternal(package, manifest, progressCallback);
//Reset cache
_cacheManager.Clear();
}
}
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 = $"{moduleInfo.Id}: {x.Description}";
progressInfo.Errors = x.Errors;
progressCallback(progressInfo);
};
try
{
((ISupportExportImportModule)moduleDescriptor.ModuleInstance).DoImport(modulePartStream, manifest, modulePorgressCallback);
}
catch (Exception ex)
{
progressInfo.Errors.Add($"{moduleInfo.Id}: {ex.ExpandExceptionMessage()}");
progressCallback(progressInfo);
}
}
}
}
}
public void DoExport(Stream outStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback,
CancellationToken cancellationToken)
{
if (manifest == null)
{
throw new ArgumentNullException("manifest");
}
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
var progressInfo = new ExportImportProgressInfo {
Description = "loading data..."
};
progressCallback(progressInfo);
using (var sw = new StreamWriter(outStream, System.Text.Encoding.UTF8))
using (var writer = new JsonTextWriter(sw))
{
writer.WriteStartObject();
progressInfo.Description = "Notifications exporting...";
progressCallback(progressInfo);
var notificationsResult = _notificationSearchService.SearchNotifications(new NotificationSearchCriteria {
Take = Int32.MaxValue, ResponseGroup = NotificationResponseGroup.Default.ToString()
});
writer.WritePropertyName("NotificationsTotalCount");
writer.WriteValue(notificationsResult.TotalCount);
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
writer.WritePropertyName("Notifications");
writer.WriteStartArray();
for (var i = 0; i < notificationsResult.TotalCount; i += _batchSize)
{
var searchResponse = _notificationSearchService.SearchNotifications(new NotificationSearchCriteria {
Skip = i, Take = _batchSize, ResponseGroup = NotificationResponseGroup.Full.ToString()
});
foreach (var notification in searchResponse.Results)
{
GetJsonSerializer().Serialize(writer, notification);
}
writer.Flush();
progressInfo.Description = $"{ Math.Min(notificationsResult.TotalCount, i + _batchSize) } of { notificationsResult.TotalCount } notifications exported";
progressCallback(progressInfo);
}
writer.WriteEndArray();
writer.WriteEndObject();
writer.Flush();
}
}
private void ImportModulesInternal(ZipArchive zipArchive, 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 = zipArchive.GetEntry(moduleInfo.PartUri);
using (var modulePartStream = modulePart.Open())
{
Action <ExportImportProgressInfo> modulePorgressCallback = (x) =>
{
progressInfo.Description = $"{moduleInfo.Id}: {x.Description}";
progressCallback(progressInfo);
};
try
{
((ISupportExportImportModule)moduleDescriptor.ModuleInstance).DoImport(modulePartStream, manifest, modulePorgressCallback);
}
catch (Exception ex)
{
progressInfo.Errors.Add($"{moduleInfo.Id}: {ex.ToString()}");
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 = Task.Run(() => _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)
{
var userExt = Task.Run(() => _securityService.FindByIdAsync(user.Id, UserDetails.Export)).Result;
if (userExt != null)
{
platformExportObj.Users.Add(userExt);
}
}
}
//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();
//Notification templates
progressInfo.Description = String.Format("Notifications: load templates...");
progressCallback(progressInfo);
platformExportObj.NotificationTemplates = _notificationTemplateService.GetAllTemplates().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);
}
}
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);
}
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>(GetJsonSerializer());
}
//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)
{
var dummy = _securityService.UpdateAsync(user).Result;
}
else
{
var dummy = _securityService.CreateAsync(user).Result;
}
}
}
//Import modules settings
if (manifest.HandleSettings)
{
//Import dynamic properties
_dynamicPropertyService.SaveProperties(platformEntries.DynamicProperties.ToArray());
foreach (var propDicGroup in platformEntries.DynamicPropertyDictionaryItems.GroupBy(x => x.PropertyId))
{
_dynamicPropertyService.SaveDictionaryItems(propDicGroup.Key, propDicGroup.ToArray());
}
foreach (var module in manifest.Modules)
{
_settingsManager.SaveSettings(platformEntries.Settings.Where(x => x.ModuleId == module.Id).ToArray());
}
}
}
}
public IHttpActionResult LoadExportManifest([FromUri] string fileUrl)
{
PlatformExportManifest retVal = null;
using (var stream = _blobStorageProvider.OpenReadOnly(fileUrl))
{
retVal = _platformExportManager.ReadExportManifest(stream);
}
return(Ok(retVal));
}
public void DoExport(Stream backupStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
{
if (manifest == null)
{
throw new ArgumentNullException(nameof(manifest));
}
var backupObject = GetBackupObject(progressCallback, manifest.HandleBinaryData);
backupObject.SerializeJson(backupStream);
}
public void DoImport_SuccessImport()
{
//Arrange
var manifest = new PlatformExportManifest();
var fileStream = new FileStream(Path.GetFullPath("export_test.json"), FileMode.Open);
//Act
_notificationsExportImportManager.ImportAsync(fileStream, null, exportImportProgressInfo => { }, new CancellationTokenWrapper(CancellationToken.None));
//Assert
fileStream.Close();
}
public PlatformExportManifest ReadPlatformExportManifest(Stream stream)
{
PlatformExportManifest retVal = null;
using (var package = ZipPackage.Open(stream, FileMode.Open))
{
var manifestPart = package.GetPart(_manifestPartUri);
using (var streamReader = new StreamReader(manifestPart.GetStream()))
{
retVal = streamReader.ReadToEnd().DeserializeXML <PlatformExportManifest>();
}
}
return(retVal);
}
public PlatformExportManifest ReadExportManifest(Stream stream)
{
PlatformExportManifest retVal = null;
using (var package = new ZipArchive(stream))
{
var manifestPart = package.GetEntry(_manifestZipEntryName.ToString());
using (var manifestStream = manifestPart.Open())
{
retVal = manifestStream.DeserializeJson <PlatformExportManifest>(GetJsonSerializer());
}
}
return(retVal);
}
public PlatformExportManifest GetNewExportManifest(string author)
{
var retVal = new PlatformExportManifest
{
Author = author,
PlatformVersion = PlatformVersion.CurrentVersion.ToString(),
Modules = InnerGetModulesWithInterface(typeof(IImportSupport)).Select(x => new ExportModuleInfo
{
Id = x.Id,
Version = x.Version.ToString()
}).ToArray()
};
return(retVal);
}
public PlatformExportManifest ReadExportManifest(Stream stream)
{
PlatformExportManifest retVal = null;
using (var package = Package.Open(stream, FileMode.Open))
{
var manifestPart = package.GetPart(_manifestPartUri);
using (var manifestStream = manifestPart.GetStream())
{
retVal = manifestStream.DeserializeJson <PlatformExportManifest>(GetJsonSerializer());
}
}
return(retVal);
}
private async Task ImportModulesInternalAsync(ZipArchive zipArchive, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback, ICancellationToken cancellationToken)
{
var errors = new StringBuilder();
var progressInfo = new ExportImportProgressInfo();
foreach (var moduleInfo in manifest.Modules)
{
var moduleDescriptor = InnerGetModulesWithInterface(typeof(IImportSupport)).FirstOrDefault(x => x.Id == moduleInfo.Id);
if (moduleDescriptor != null)
{
var modulePart = zipArchive.GetEntry(moduleInfo.PartUri.TrimStart('/'));
using (var modulePartStream = modulePart.Open())
{
void ModuleProgressCallback(ExportImportProgressInfo x)
{
progressInfo.Description = $"{moduleInfo.Id}: {x.Description}";
progressInfo.Errors = x.Errors;
progressCallback(progressInfo);
}
if (moduleDescriptor.ModuleInstance is IImportSupport importer)
{
try
{
//TODO: Add JsonConverter which will be materialized concrete ExportImport option type
var options = manifest.Options
.DefaultIfEmpty(new ExportImportOptions {
HandleBinaryData = manifest.HandleBinaryData, ModuleIdentity = new ModuleIdentity(moduleDescriptor.Identity.Id, moduleDescriptor.Identity.Version)
})
.FirstOrDefault(x => x.ModuleIdentity.Id == moduleDescriptor.Identity.Id);
await importer.ImportAsync(modulePartStream, options, ModuleProgressCallback, cancellationToken);
}
catch (Exception ex)
{
errors.AppendLine($"<b> {moduleInfo.Id} </b>: {ex} <br><br>");
progressInfo.Errors.Add($"{moduleInfo.Id}: {ex}");
progressCallback(progressInfo);
}
}
}
}
}
if (errors.Length != 0)
{
throw new InvalidOperationException(errors.ToString());
}
}
public PlatformExportManifest GetNewExportManifest(string author)
{
var retVal = new PlatformExportManifest
{
Author = author,
PlatformVersion = PlatformVersion.CurrentVersion.ToString(),
Modules = InnerGetModulesWithInterface(typeof(ISupportExportImportModule)).Select(x => new ExportModuleInfo
{
Id = x.Id,
Dependencies = x.Dependencies != null ? x.Dependencies.ToArray() : null,
Version = x.Version,
Description = ((ISupportExportImportModule)x.ModuleInfo.ModuleInstance).ExportDescription
}).ToArray()
};
return(retVal);
}
private async Task ExportModulesInternalAsync(ZipArchive zipArchive, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback, ICancellationToken cancellationToken)
{
var progressInfo = new ExportImportProgressInfo();
foreach (var module in manifest.Modules)
{
var moduleDescriptor = InnerGetModulesWithInterface(typeof(IImportSupport)).FirstOrDefault(x => x.Id == module.Id);
if (moduleDescriptor != null)
{
//Create part for module
var moduleZipEntryName = module.Id + ".json";
var zipEntry = zipArchive.CreateEntry(moduleZipEntryName, CompressionLevel.Optimal);
void ModuleProgressCallback(ExportImportProgressInfo x)
{
progressInfo.Description = $"{ module.Id }: { x.Description }";
progressInfo.Errors = x.Errors;
progressCallback(progressInfo);
}
progressInfo.Description = $"{module.Id}: exporting...";
progressCallback(progressInfo);
if (moduleDescriptor.ModuleInstance is IExportSupport exporter)
{
try
{
//TODO: Add JsonConverter which will be materialized concrete ExportImport option type
//ToDo: Added check ExportImportOptions for modules (DefaultIfEmpty)
var options = manifest.Options
.DefaultIfEmpty(new ExportImportOptions {
HandleBinaryData = manifest.HandleBinaryData, ModuleIdentity = new ModuleIdentity(module.Id, SemanticVersion.Parse(module.Version))
})
.FirstOrDefault(x => x.ModuleIdentity.Id == moduleDescriptor.Identity.Id);
await exporter.ExportAsync(zipEntry.Open(), options, ModuleProgressCallback, cancellationToken);
}
catch (Exception ex)
{
progressInfo.Errors.Add($"{ module.Id}: {ex}");
progressCallback(progressInfo);
}
}
module.PartUri = moduleZipEntryName;
}
}
}
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);
}
}
public void DoExport(Stream outStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
{
var progressInfo = new ExportImportProgressInfo {
Description = "loading data..."
};
progressCallback(progressInfo);
using (StreamWriter sw = new StreamWriter(outStream, Encoding.UTF8))
{
using (JsonTextWriter writer = new JsonTextWriter(sw))
{
writer.WriteStartObject();
ExportDerivativeContractEntity(writer, _serializer, manifest, progressInfo, progressCallback);
ExportDerivativeContractItemEntity(writer, _serializer, manifest, progressInfo, progressCallback);
writer.WriteEndObject();
writer.Flush();
}
}
}
public void DoExport(Stream outStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
{
var progressInfo = new ExportImportProgressInfo {
Description = "loading data..."
};
progressCallback(progressInfo);
using (StreamWriter sw = new StreamWriter(outStream, Encoding.UTF8))
using (JsonTextWriter writer = new JsonTextWriter(sw))
{
writer.WriteStartObject();
ExportCatalogs(writer, _serializer, manifest, progressInfo, progressCallback);
ExportCategories(writer, _serializer, manifest, progressInfo, progressCallback);
ExportProperties(writer, _serializer, manifest, progressInfo, progressCallback);
ExportProducts(writer, _serializer, manifest, progressInfo, progressCallback);
writer.WriteEndObject();
writer.Flush();
}
}
public async Task ImportAsync(Stream inputStream, PlatformExportManifest importOptions, Action <ExportImportProgressInfo> progressCallback, ICancellationToken сancellationToken)
{
if (importOptions == null)
{
throw new ArgumentNullException(nameof(importOptions));
}
var progressInfo = new ExportImportProgressInfo();
progressInfo.Description = "Starting platform import...";
progressCallback(progressInfo);
using (var zipArchive = new ZipArchive(inputStream, ZipArchiveMode.Read, true))
using (EventSuppressor.SupressEvents())
{
//Import selected platform entries
await ImportPlatformEntriesInternalAsync(zipArchive, importOptions, progressCallback, сancellationToken);
//Import selected modules
await ImportModulesInternalAsync(zipArchive, importOptions, progressCallback, сancellationToken);
}
}
public void DoImport(Stream inputStream, PlatformExportManifest manifest,
Action <ExportImportProgressInfo> progressCallback)
{
var progressInfo = new ExportImportProgressInfo();
using (StreamReader streamReader = new StreamReader(inputStream))
{
using (JsonTextReader jsonReader = new JsonTextReader(streamReader))
{
while (jsonReader.Read())
{
if (jsonReader.TokenType != JsonToken.PropertyName)
{
continue;
}
switch (jsonReader.Value.ToString())
{
case "Options":
jsonReader.Read();
var options = _serializer.Deserialize <ThumbnailOption[]>(jsonReader);
progressInfo.Description = $"Importing {options.Length} options...";
progressCallback(progressInfo);
_optionService.SaveOrUpdate(options);
break;
case "Tasks":
jsonReader.Read();
var tasks = _serializer.Deserialize <ThumbnailTask[]>(jsonReader);
progressInfo.Description = $"Importing {tasks.Length} tasks...";
progressCallback(progressInfo);
_taskService.SaveOrUpdate(tasks);
break;
}
}
}
}
}
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 = $"{module.Id}: {x.Description}";
progressInfo.Errors = x.Errors;
progressCallback(progressInfo);
};
progressInfo.Description = $"{module.Id}: exporting...";
progressCallback(progressInfo);
try
{
((ISupportExportImportModule)moduleDescriptor.ModuleInstance).DoExport(modulePart.GetStream(), manifest, modulePorgressCallback);
}
catch (Exception ex)
{
progressInfo.Errors.Add($"{module.Id}: {ex.ExpandExceptionMessage()}");
progressCallback(progressInfo);
}
module.PartUri = modulePartUri.ToString();
}
}
}
private void ExportTasks(JsonTextWriter writer, JsonSerializer serializer, PlatformExportManifest manifest,
ExportImportProgressInfo progressInfo, Action <ExportImportProgressInfo> progressCallback)
{
progressInfo.Description = "Exporting tasks...";
progressCallback(progressInfo);
var totalCount = _taskSearchService.Search(new ThumbnailTaskSearchCriteria()
{
Take = 0, Skip = 0
})
.TotalCount;
writer.WritePropertyName("TakskTotalCount");
writer.WriteValue(totalCount);
writer.WritePropertyName("Tasks");
writer.WriteStartArray();
for (int i = 0; i < totalCount; i += _batchSize)
{
var tasks = _taskSearchService.Search(new ThumbnailTaskSearchCriteria {
Take = _batchSize, Skip = i
})
.Results;
foreach (var task in tasks)
{
serializer.Serialize(writer, task);
}
writer.Flush();
progressInfo.Description = $"{Math.Min(totalCount, i + _batchSize)} of {totalCount} tasks exported";
progressCallback(progressInfo);
}
writer.WriteEndArray();
}
public void Export(Stream outStream, PlatformExportManifest manifest, Action <ExportImportProgressInfo> progressCallback)
{
if (manifest == null)
{
throw new ArgumentNullException("manifest");
}
using (var package = Package.Open(outStream, FileMode.Create))
{
//Export all selected platform entries
ExportPlatformEntriesInternal(package, manifest, progressCallback);
//Export all selected modules
ExportModulesInternal(package, manifest, progressCallback);
//Write system information about exported modules
var manifestPart = package.CreatePart(_manifestPartUri, "application/javascript");
//After all modules exported need write export manifest part
using (var stream = manifestPart.GetStream())
{
manifest.SerializeJson(stream, GetJsonSerializer());
}
}
}
