public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
CheckPoint.Progress += 100;
CheckPoint.Completed = true;
CheckPoint.TotalItems = 0;
CheckPoint.ProcessedItems = 0;
CheckPointStageCallback(this);
//No implementation required in export users child as everything is exported in parent service.
}
private static void DoPacking(ExportImportJob exportJob, string dbName)
{
var exportFileArchive = Path.Combine(ExportFolder, exportJob.Directory, Constants.ExportZipDbName);
var folderOffset = exportFileArchive.IndexOf(Constants.ExportZipDbName, StringComparison.Ordinal);
File.Delete(CompressionUtil.AddFileToArchive(dbName, exportFileArchive, folderOffset)
? dbName
: exportFileArchive);
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
if (this.CheckPoint.Stage > 0)
{
return;
}
var profileProperties = this.Repository.GetAllItems <ExportProfileProperty>().ToList();
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? profileProperties.Count : this.CheckPoint.TotalItems;
this.CheckPointStageCallback(this);
foreach (var profileProperty in profileProperties)
{
if (this.CheckCancelled(importJob))
{
return;
}
var existingProfileProperty = CBO.FillObject <ExportProfileProperty>(DotNetNuke.Data.DataProvider.Instance()
.GetPropertyDefinitionByName(importJob.PortalId, profileProperty.PropertyName));
if (existingProfileProperty != null)
{
switch (importDto.CollisionResolution)
{
case CollisionResolution.Overwrite:
var modifiedById = Util.GetUserIdByName(importJob, profileProperty.LastModifiedByUserId, profileProperty.LastModifiedByUserName);
ProcessUpdateProfileProperty(profileProperty, existingProfileProperty, modifiedById);
break;
case CollisionResolution.Ignore:
break;
default:
throw new ArgumentOutOfRangeException(importDto.CollisionResolution.ToString());
}
}
else
{
var createdById = Util.GetUserIdByName(
importJob,
profileProperty.CreatedByUserId,
profileProperty.CreatedByUserName);
ProcessCreateProfileProperty(importJob, profileProperty, createdById);
}
}
this.Result.AddSummary("Imported Profile Properties", profileProperties.Count.ToString());
this.CheckPoint.ProcessedItems = profileProperties.Count;
this.CheckPoint.Completed = true;
this.CheckPoint.Progress = 100;
this.CheckPoint.Stage++;
this.CheckPointStageCallback(this);
}
private void ProcessPortalSettings(ExportImportJob importJob, ImportDto importDto,
IEnumerable<ExportPortalSetting> portalSettings)
{
var portalId = importJob.PortalId;
var localPortalSettings =
CBO.FillCollection<ExportPortalSetting>(DataProvider.Instance().GetPortalSettings(portalId, DateUtils.GetDatabaseUtcTime().AddYears(1), null));
foreach (var exportPortalSetting in portalSettings)
{
if (CheckCancelled(importJob)) return;
var existingPortalSetting =
localPortalSettings.FirstOrDefault(
t =>
t.SettingName == exportPortalSetting.SettingName &&
(t.CultureCode == exportPortalSetting.CultureCode ||
(string.IsNullOrEmpty(t.CultureCode) &&
string.IsNullOrEmpty(exportPortalSetting.CultureCode))));
var isUpdate = false;
if (existingPortalSetting != null)
{
switch (importDto.CollisionResolution)
{
case CollisionResolution.Overwrite:
isUpdate = true;
break;
case CollisionResolution.Ignore:
Result.AddLogEntry("Ignored portal settings", exportPortalSetting.SettingName);
continue;
default:
throw new ArgumentOutOfRangeException(importDto.CollisionResolution.ToString());
}
}
if (isUpdate)
{
var modifiedBy = Util.GetUserIdByName(importJob, exportPortalSetting.LastModifiedByUserId,
exportPortalSetting.LastModifiedByUserName);
exportPortalSetting.PortalSettingId = existingPortalSetting.PortalSettingId;
DotNetNuke.Data.DataProvider.Instance()
.UpdatePortalSetting(importJob.PortalId, exportPortalSetting.SettingName,
exportPortalSetting.SettingValue, modifiedBy, exportPortalSetting.CultureCode);
Result.AddLogEntry("Updated portal settings", exportPortalSetting.SettingName);
}
else
{
var createdBy = Util.GetUserIdByName(importJob, exportPortalSetting.CreatedByUserId, exportPortalSetting.CreatedByUserName);
DotNetNuke.Data.DataProvider.Instance()
.UpdatePortalSetting(importJob.PortalId, exportPortalSetting.SettingName,
exportPortalSetting.SettingValue, createdBy, exportPortalSetting.CultureCode);
Result.AddLogEntry("Added portal settings", exportPortalSetting.SettingName);
}
}
}
private static void ProcessCreateProfileProperty(ExportImportJob importJob,
ExportProfileProperty profileProperty, int createdById)
{
DotNetNuke.Data.DataProvider.Instance()
.AddPropertyDefinition(importJob.PortalId, profileProperty.ModuleDefId ?? Null.NullInteger,
profileProperty.DataType ?? Null.NullInteger,
profileProperty.DefaultValue, profileProperty.PropertyCategory, profileProperty.PropertyName,
profileProperty.ReadOnly, profileProperty.Required,
profileProperty.ValidationExpression, profileProperty.ViewOrder, profileProperty.Visible,
profileProperty.Length, profileProperty.DefaultVisibility, createdById);
}
private void ProcessPortalLanguages(ExportImportJob importJob, ImportDto importDto,
IEnumerable<ExportPortalLanguage> portalLanguages)
{
var portalId = importJob.PortalId;
var localPortalLanguages =
CBO.FillCollection<ExportPortalLanguage>(DataProvider.Instance().GetPortalLanguages(portalId, DateUtils.GetDatabaseUtcTime().AddYears(1), null));
var localLanguages = CBO.FillCollection<Locale>(DotNetNuke.Data.DataProvider.Instance().GetLanguages());
foreach (var exportPortalLanguage in portalLanguages)
{
if (CheckCancelled(importJob)) return;
var localLanguageId =
localLanguages.FirstOrDefault(x => x.Code == exportPortalLanguage.CultureCode)?.LanguageId;
var existingPortalLanguage =
localPortalLanguages.FirstOrDefault(
t =>
t.LanguageId == localLanguageId);
var isUpdate = false;
if (existingPortalLanguage != null)
{
switch (importDto.CollisionResolution)
{
case CollisionResolution.Overwrite:
isUpdate = true;
break;
case CollisionResolution.Ignore:
Result.AddLogEntry("Ignored portal language", exportPortalLanguage.CultureCode);
continue;
default:
throw new ArgumentOutOfRangeException(importDto.CollisionResolution.ToString());
}
}
if (isUpdate)
{
var modifiedBy = Util.GetUserIdByName(importJob, exportPortalLanguage.LastModifiedByUserId, exportPortalLanguage.LastModifiedByUserName);
DotNetNuke.Data.DataProvider.Instance()
.UpdatePortalLanguage(importJob.PortalId, exportPortalLanguage.LanguageId,
exportPortalLanguage.IsPublished, modifiedBy);
Result.AddLogEntry("Updated portal language", exportPortalLanguage.CultureCode);
}
else
{
var createdBy = Util.GetUserIdByName(importJob, exportPortalLanguage.CreatedByUserId, exportPortalLanguage.CreatedByUserName);
exportPortalLanguage.PortalLanguageId = DotNetNuke.Data.DataProvider.Instance()
.AddPortalLanguage(importJob.PortalId, exportPortalLanguage.LanguageId,
exportPortalLanguage.IsPublished, createdBy);
Result.AddLogEntry("Added portal language", exportPortalLanguage.CultureCode);
}
}
}
private static void DoUnPacking(ExportImportJob importJob)
{
var extractFolder = Path.Combine(ExportFolder, importJob.Directory);
var dbName = Path.Combine(extractFolder, Constants.ExportDbName);
if (File.Exists(dbName))
{
return;
}
var zipDbName = Path.Combine(extractFolder, Constants.ExportZipDbName);
CompressionUtil.UnZipFileFromArchive(Constants.ExportDbName, zipDbName, extractFolder, false);
}
private static bool CheckCancelledCallBack(ExportImportJob job)
{
var job2 = CachingProvider.Instance().GetItem(Util.GetExpImpJobCacheKey(job)) as ExportImportJob;
if (job2 == null)
{
job2 = EntitiesController.Instance.GetJobById(job.JobId);
job.IsCancelled = job2.IsCancelled;
AddJobToCache(job2);
}
return(job2.IsCancelled);
}
public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
if (this.CheckPoint.Stage > 0)
{
return;
}
if (this.CheckCancelled(exportJob))
{
return;
}
var fromDate = (exportDto.FromDateUtc ?? Constants.MinDbTime).ToLocalTime();
var toDate = exportDto.ToDateUtc.ToLocalTime();
var contentWorkflows = GetWorkflows(exportDto.PortalId, exportDto.IncludeDeletions);
if (contentWorkflows.Count > 0)
{
var defaultWorkflowId = TabWorkflowSettings.Instance.GetDefaultTabWorkflowId(exportDto.PortalId);
var defaultWorkflow = contentWorkflows.FirstOrDefault(w => w.WorkflowID == defaultWorkflowId);
if (defaultWorkflow != null)
{
defaultWorkflow.IsDefault = true;
}
this.CheckPoint.TotalItems = contentWorkflows.Count;
this.Repository.CreateItems(contentWorkflows);
this.Result.AddLogEntry("Exported ContentWorkflows", contentWorkflows.Count.ToString());
foreach (var workflow in contentWorkflows)
{
var contentWorkflowStates = GetWorkflowStates(workflow.WorkflowID);
this.Repository.CreateItems(contentWorkflowStates, workflow.Id);
foreach (var workflowState in contentWorkflowStates)
{
var contentWorkflowStatePermissions = GetWorkflowStatePermissions(workflowState.StateID, toDate, fromDate);
this.Repository.CreateItems(contentWorkflowStatePermissions, workflowState.Id);
}
}
}
this.CheckPoint.Progress = 100;
this.CheckPoint.Completed = true;
this.CheckPoint.Stage++;
this.CheckPoint.StageData = null;
this.CheckPointStageCallback(this);
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? this.GetImportTotal() : this.CheckPoint.TotalItems;
if (this.CheckPointStageCallback(this))
{
return;
}
if (this.CheckPoint.Stage > 1)
{
return;
}
if (this.CheckPoint.Stage == 0)
{
var portalSettings = this.Repository.GetAllItems <ExportPortalSetting>().ToList();
this.ProcessPortalSettings(importJob, importDto, portalSettings);
this.CheckPoint.TotalItems = this.GetImportTotal();
this.Result.AddSummary("Imported Portal Settings", portalSettings.Count.ToString());
this.CheckPoint.Progress += 50;
this.CheckPoint.Stage++;
this.CheckPoint.ProcessedItems = portalSettings.Count;
if (this.CheckPointStageCallback(this))
{
return;
}
}
if (this.CheckPoint.Stage == 1)
{
var portalLanguages = this.Repository.GetAllItems <ExportPortalLanguage>().ToList();
this.ProcessPortalLanguages(importJob, importDto, portalLanguages);
this.Result.AddSummary("Imported Portal Languages", portalLanguages.Count.ToString());
this.CheckPoint.Progress += 50;
this.CheckPoint.Completed = true;
this.CheckPoint.Stage++;
this.CheckPoint.ProcessedItems += portalLanguages.Count;
this.CheckPointStageCallback(this);
}
/*
* ProgressPercentage = 0;
* var portalLocalizations = Repository.GetAllItems<ExportPortalLocalization>().ToList();
* ProcessPortalLocalizations(importJob, importDto, portalLocalizations);
* Result.AddSummary("Imported Portal Localizations", portalLocalizations.Count.ToString());
* ProgressPercentage += 40;
*/
}
public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
var fromDate = (exportDto.FromDateUtc ?? Constants.MinDbTime).ToLocalTime();
var toDate = exportDto.ToDateUtc.ToLocalTime();
if (this.CheckCancelled(exportJob))
{
return;
}
if (this.CheckPoint.Stage > 0)
{
return;
}
if (this.CheckCancelled(exportJob))
{
return;
}
var profileProperties = CBO.FillCollection <ExportProfileProperty>(
DataProvider.Instance()
.GetPropertyDefinitionsByPortal(
exportJob.PortalId,
exportDto.IncludeDeletions,
toDate,
fromDate))
.ToList();
this.CheckPoint.Progress = 50;
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? profileProperties.Count : this.CheckPoint.TotalItems;
this.CheckPointStageCallback(this);
if (this.CheckCancelled(exportJob))
{
return;
}
this.Repository.CreateItems(profileProperties);
this.Result.AddSummary("Exported Profile Properties", profileProperties.Count.ToString());
this.CheckPoint.Progress = 100;
this.CheckPoint.ProcessedItems = profileProperties.Count;
this.CheckPoint.Completed = true;
this.CheckPoint.Stage++;
this.CheckPointStageCallback(this);
}
/// <summary>Creates a package manifest.</summary>
/// <param name="exportJob">The export job.</param>
/// <param name="exportFileInfo">The export file info.</param>
/// <param name="summary">The summary.</param>
public void CreatePackageManifest(ExportImportJob exportJob, ExportFileInfo exportFileInfo, ImportExportSummary summary)
{
var filePath = Path.Combine(ExportFolder, exportJob.Directory, Constants.ExportManifestName);
var portal = PortalController.Instance.GetPortal(exportJob.PortalId);
var packageInfo = new ImportPackageInfo
{
Summary = summary,
PackageId = exportJob.Directory,
Name = exportJob.Name,
Description = exportJob.Description,
ExporTime = exportJob.CreatedOnDate,
PortalName = portal?.PortalName,
};
Util.WriteJson(filePath, packageInfo);
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
if (CheckCancelled(importJob))
{
return;
}
//Skip the export if all the templates have been processed already.
if (CheckPoint.Stage >= 1 || CheckPoint.Completed)
{
return;
}
_exportImportJob = importJob;
ProcessImportModulePackages(importDto);
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
if (this.CheckPoint.Stage > 0)
{
return;
}
if (this.CheckCancelled(importJob))
{
return;
}
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? this.GetImportTotal() : this.CheckPoint.TotalItems;
if (this.CheckPoint.Stage == 0)
{
var otherScopeTypes = this.Repository.GetAllItems <TaxonomyScopeType>().ToList();
// the table Taxonomy_ScopeTypes is used for lookup only and never changed/updated in the database
// CheckPoint.Progress = 10;
// var otherVocabularyTypes = Repository.GetAllItems<TaxonomyVocabularyType>().ToList();
// the table Taxonomy_VocabularyTypes is used for lookup only and never changed/updated in the database
this.CheckPoint.Progress = 20;
var otherVocabularies = this.Repository.GetAllItems <TaxonomyVocabulary>().ToList();
this.ProcessVocabularies(importJob, importDto, otherScopeTypes, otherVocabularies);
this.Repository.UpdateItems(otherVocabularies);
this.Result.AddSummary("Imported Vocabularies", otherVocabularies.Count.ToString());
this.CheckPoint.Progress = 60;
this.CheckPoint.ProcessedItems += otherVocabularies.Count;
var otherTaxonomyTerms = this.Repository.GetAllItems <TaxonomyTerm>().ToList();
this.ProcessTaxonomyTerms(importJob, importDto, otherVocabularies, otherTaxonomyTerms);
this.Repository.UpdateItems(otherTaxonomyTerms);
this.Result.AddSummary("Imported Terms", otherTaxonomyTerms.Count.ToString());
this.CheckPoint.Progress = 100;
this.CheckPoint.ProcessedItems += otherTaxonomyTerms.Count;
this.CheckPoint.Stage++;
this.CheckPoint.Completed = true;
this.CheckPointStageCallback(this);
}
}
private static JobItem ToJobItem(ExportImportJob job)
{
var user = UserController.Instance.GetUserById(job.PortalId, job.CreatedByUserId);
var name = job.JobType == JobType.Import ? JsonConvert.DeserializeObject <ImportDto>(job.JobObject)?.ExportDto?.ExportName : job.Name;
return(new JobItem
{
JobId = job.JobId,
PortalId = job.PortalId,
User = user?.DisplayName ?? user?.Username ?? job.CreatedByUserId.ToString(),
JobType = Localization.GetString("JobType_" + job.JobType, Constants.SharedResources),
Status = (int)job.JobStatus,
Cancelled = job.IsCancelled,
JobStatus = Localization.GetString("JobStatus_" + job.JobStatus, Constants.SharedResources),
Name = name,
Description = job.Description,
CreatedOn = job.CreatedOnDate,
CompletedOn = job.CompletedOnDate,
ExportFile = job.CompletedOnDate.HasValue ? job.Directory : null,
});
}
private static void DeleteJobData(ExportImportJob job)
{
if (job.JobType != JobType.Export)
{
return;
}
var jobFolder = Path.Combine(ExportFolder, job.Directory);
try
{
if (Directory.Exists(jobFolder))
{
Directory.Delete(jobFolder, true);
}
}
catch (Exception ex)
{
Logger.Error(
$"Failed to delete the job data. Error:{ex.Message}. It will need to be deleted manually. Folder Path:{jobFolder}");
}
}
public override uint Priority => 18; // execute before pages service.
public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
if (this.CheckCancelled(exportJob))
{
return;
}
// Skip the export if all the folders have been processed already.
if (this.CheckPoint.Stage >= 1)
{
return;
}
// Create Zip File to hold files
var skip = this.GetCurrentSkip();
var currentIndex = skip;
var totalPackagesExported = 0;
try
{
var packagesZipFileFormat = $"{Globals.ApplicationMapPath}{Constants.ExportFolder}{{0}}\\{Constants.ExportZipPackages}";
var packagesZipFile = string.Format(packagesZipFileFormat, exportJob.Directory.TrimEnd('\\').TrimEnd('/'));
if (this.CheckPoint.Stage == 0)
{
var fromDate = exportDto.FromDateUtc ?? Constants.MinDbTime;
var toDate = exportDto.ToDateUtc;
// export skin packages.
var extensionPackagesBackupFolder = Path.Combine(Globals.ApplicationMapPath, DotNetNuke.Services.Installer.Util.BackupInstallPackageFolder);
var skinPackageFiles = Directory.GetFiles(extensionPackagesBackupFolder).Where(f => this.IsValidPackage(f, fromDate, toDate)).ToList();
var totalPackages = skinPackageFiles.Count;
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? totalPackages : this.CheckPoint.TotalItems;
if (this.CheckPointStageCallback(this))
{
return;
}
using (var zipArchive = CompressionUtil.OpenCreate(packagesZipFile))
{
foreach (var file in skinPackageFiles)
{
var exportPackage = this.GenerateExportPackage(file);
if (exportPackage != null)
{
this.Repository.CreateItem(exportPackage, null);
totalPackagesExported += 1;
var folderOffset = Path.GetDirectoryName(file)?.Length + 1;
CompressionUtil.AddFileToArchive(zipArchive, file, folderOffset.GetValueOrDefault(0));
}
this.CheckPoint.ProcessedItems++;
this.CheckPoint.Progress = this.CheckPoint.ProcessedItems * 100.0 / totalPackages;
currentIndex++;
// After every 10 items, call the checkpoint stage. This is to avoid too many frequent updates to DB.
if (currentIndex % 10 == 0 && this.CheckPointStageCallback(this))
{
return;
}
}
}
this.CheckPoint.Stage++;
currentIndex = 0;
this.CheckPoint.Completed = true;
this.CheckPoint.Progress = 100;
}
}
finally
{
this.CheckPoint.StageData = currentIndex > 0 ? JsonConvert.SerializeObject(new { skip = currentIndex }) : null;
this.CheckPointStageCallback(this);
this.Result.AddSummary("Exported Packages", totalPackagesExported.ToString());
}
}
public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
var fromDate = (exportDto.FromDateUtc ?? Constants.MinDbTime).ToLocalTime();
var toDate = exportDto.ToDateUtc.ToLocalTime();
if (CheckPoint.Stage > 1)
{
return;
}
if (CheckCancelled(exportJob))
{
return;
}
List <ExportPortalLanguage> portalLanguages = null;
if (CheckPoint.Stage == 0)
{
var portalSettings = new List <ExportPortalSetting>();
var settingToMigrate =
SettingsController.Instance.GetSetting(Constants.PortalSettingExportKey)?.SettingValue?.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
if (settingToMigrate != null)
{
portalSettings = CBO.FillCollection <ExportPortalSetting>(DataProvider.Instance().GetPortalSettings(exportJob.PortalId, toDate, fromDate));
//Migrate only allowed portal settings.
portalSettings =
portalSettings.Where(x => settingToMigrate.Any(setting => setting.Trim().Equals(x.SettingName, StringComparison.InvariantCultureIgnoreCase))).ToList();
//Update the total items count in the check points. This should be updated only once.
CheckPoint.TotalItems = CheckPoint.TotalItems <= 0 ? portalSettings.Count : CheckPoint.TotalItems;
if (CheckPoint.TotalItems == portalSettings.Count)
{
portalLanguages =
CBO.FillCollection <ExportPortalLanguage>(
DataProvider.Instance().GetPortalLanguages(exportJob.PortalId, toDate, fromDate));
CheckPoint.TotalItems += portalLanguages.Count;
}
CheckPointStageCallback(this);
Repository.CreateItems(portalSettings);
}
Result.AddSummary("Exported Portal Settings", portalSettings.Count.ToString());
CheckPoint.Progress = 50;
CheckPoint.ProcessedItems = portalSettings.Count;
CheckPoint.Stage++;
if (CheckPointStageCallback(this))
{
return;
}
}
if (CheckPoint.Stage == 1)
{
if (CheckCancelled(exportJob))
{
return;
}
if (portalLanguages == null)
{
portalLanguages = CBO.FillCollection <ExportPortalLanguage>(DataProvider.Instance()
.GetPortalLanguages(exportJob.PortalId, toDate, fromDate));
}
Repository.CreateItems(portalLanguages);
Result.AddSummary("Exported Portal Languages", portalLanguages.Count.ToString());
CheckPoint.Progress = 100;
CheckPoint.Completed = true;
CheckPoint.Stage++;
CheckPoint.ProcessedItems += portalLanguages.Count;
CheckPointStageCallback(this);
}
}
public static string GetExpImpJobCacheKey(ExportImportJob job)
{
return(string.Join(":", "ExpImpKey", job.PortalId.ToString(), job.JobId.ToString()));
}
public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
if (this.CheckCancelled(exportJob))
{
return;
}
var fromDateUtc = exportDto.FromDateUtc;
var toDateUtc = exportDto.ToDateUtc;
var portalId = exportJob.PortalId;
var pageIndex = 0;
const int pageSize = Constants.DefaultPageSize;
var totalUsersExported = 0;
var totalUserRolesExported = 0;
var totalPortalsExported = 0;
var totalProfilesExported = 0;
var totalAuthenticationExported = 0;
var totalAspnetUserExported = 0;
var totalAspnetMembershipExported = 0;
var totalUsers = DataProvider.Instance().GetUsersCount(portalId, exportDto.IncludeDeletions, toDateUtc, fromDateUtc);
if (totalUsers == 0)
{
this.CheckPoint.Completed = true;
this.CheckPointStageCallback(this);
return;
}
var totalPages = Util.CalculateTotalPages(totalUsers, pageSize);
// Skip the export if all the users has been processed already.
if (this.CheckPoint.Stage >= totalPages)
{
return;
}
// Check if there is any pending stage or partially processed data.
if (this.CheckPoint.Stage > 0)
{
pageIndex = this.CheckPoint.Stage;
}
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? totalUsers : this.CheckPoint.TotalItems;
this.CheckPoint.ProcessedItems = this.CheckPoint.Stage * pageSize;
if (this.CheckPointStageCallback(this))
{
return;
}
var includeProfile = exportDto.IncludeProperfileProperties;
try
{
while (pageIndex < totalPages)
{
if (this.CheckCancelled(exportJob))
{
return;
}
var exportUsersList = new List <ExportUser>();
var exportAspnetUserList = new List <ExportAspnetUser>();
var exportAspnetMembershipList = new List <ExportAspnetMembership>();
var exportUserRoleList = new List <ExportUserRole>();
var exportUserPortalList = new List <ExportUserPortal>();
var exportUserAuthenticationList = new List <ExportUserAuthentication>();
var exportUserProfileList = new List <ExportUserProfile>();
try
{
using (var reader = DataProvider.Instance()
.GetAllUsers(portalId, pageIndex, pageSize, exportDto.IncludeDeletions, toDateUtc, fromDateUtc))
{
CBO.FillCollection(reader, exportUsersList, false);
reader.NextResult();
CBO.FillCollection(reader, exportUserAuthenticationList, false);
reader.NextResult();
CBO.FillCollection(reader, exportUserRoleList, false);
reader.NextResult();
if (includeProfile)
{
CBO.FillCollection(reader, exportUserProfileList, false);
}
reader.NextResult();
CBO.FillCollection(reader, exportUserPortalList, false);
reader.NextResult();
CBO.FillCollection(reader, exportAspnetUserList, false);
reader.NextResult();
CBO.FillCollection(reader, exportAspnetMembershipList, true);
}
this.Repository.CreateItems(exportUsersList, null);
totalUsersExported += exportUsersList.Count;
exportUserAuthenticationList.ForEach(
x =>
{
x.ReferenceId = exportUsersList.FirstOrDefault(user => user.UserId == x.UserId)?.Id;
});
this.Repository.CreateItems(exportUserAuthenticationList, null);
totalAuthenticationExported += exportUserAuthenticationList.Count;
exportUserRoleList.ForEach(
x =>
{
x.ReferenceId = exportUsersList.FirstOrDefault(user => user.UserId == x.UserId)?.Id;
});
this.Repository.CreateItems(exportUserRoleList, null);
totalUserRolesExported += exportUserRoleList.Count;
if (includeProfile)
{
exportUserProfileList.ForEach(
x =>
{
x.ReferenceId = exportUsersList.FirstOrDefault(user => user.UserId == x.UserId)?.Id;
});
this.Repository.CreateItems(exportUserProfileList, null);
totalProfilesExported += exportUserProfileList.Count;
}
exportUserPortalList.ForEach(
x =>
{
x.ReferenceId = exportUsersList.FirstOrDefault(user => user.UserId == x.UserId)?.Id;
});
this.Repository.CreateItems(exportUserPortalList, null);
totalPortalsExported += exportUserPortalList.Count;
exportAspnetUserList.ForEach(
x =>
{
x.ReferenceId = exportUsersList.FirstOrDefault(user => user.Username == x.UserName)?.Id;
});
this.Repository.CreateItems(exportAspnetUserList, null);
totalAspnetUserExported += exportAspnetUserList.Count;
exportAspnetMembershipList.ForEach(
x =>
{
x.ReferenceId = exportAspnetUserList.FirstOrDefault(user => user.UserId == x.UserId)?.Id;
});
this.Repository.CreateItems(exportAspnetMembershipList, null);
totalAspnetMembershipExported += exportAspnetMembershipList.Count;
this.CheckPoint.ProcessedItems += exportUsersList.Count;
}
catch (Exception ex)
{
this.Result.AddLogEntry($"Exporting Users from {pageIndex * pageSize} to {(pageIndex * pageSize) + pageSize} exception", ex.Message, ReportLevel.Error);
}
this.CheckPoint.Progress = this.CheckPoint.ProcessedItems * 100.0 / totalUsers;
this.CheckPoint.Stage++;
if (this.CheckPointStageCallback(this))
{
return;
}
// Rebuild the indexes in the exported database.
this.Repository.RebuildIndex <ExportUser>(x => x.Id, true);
this.Repository.RebuildIndex <ExportUserPortal>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportAspnetUser>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportAspnetMembership>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportUserAuthentication>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportUserRole>(x => x.ReferenceId);
if (includeProfile)
{
this.Repository.RebuildIndex <ExportUserProfile>(x => x.ReferenceId);
}
pageIndex++;
}
this.CheckPoint.Completed = true;
this.CheckPoint.Progress = 100;
}
finally
{
this.CheckPointStageCallback(this);
this.Result.AddSummary("Exported Users", totalUsersExported.ToString());
this.Result.AddSummary("Exported User Portals", totalPortalsExported.ToString());
this.Result.AddSummary("Exported User Roles", totalUserRolesExported.ToString());
if (includeProfile)
{
this.Result.AddSummary("Exported User Profiles", totalProfilesExported.ToString());
}
this.Result.AddSummary("Exported User Authentication", totalAuthenticationExported.ToString());
this.Result.AddSummary("Exported Aspnet User", totalAspnetUserExported.ToString());
this.Result.AddSummary("Exported Aspnet Membership", totalAspnetMembershipExported.ToString());
}
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
if (this.CheckCancelled(importJob))
{
return;
}
const int pageSize = Constants.DefaultPageSize;
var totalUsersImported = 0;
var totalPortalsImported = 0;
var totalAspnetUserImported = 0;
var totalAspnetMembershipImported = 0;
var totalUserAuthenticationCount = 0;
var totalUsers = this.Repository.GetCount <ExportUser>();
if (totalUsers == 0)
{
this.CheckPoint.Completed = true;
this.CheckPointStageCallback(this);
return;
}
var totalPages = Util.CalculateTotalPages(totalUsers, pageSize);
// Skip the import if all the users has been processed already.
if (this.CheckPoint.Stage >= totalPages)
{
return;
}
var pageIndex = this.CheckPoint.Stage;
var totalUsersToBeProcessed = totalUsers - (pageIndex * pageSize);
// Update the total items count in the check points. This should be updated only once.
this.CheckPoint.TotalItems = this.CheckPoint.TotalItems <= 0 ? totalUsers : this.CheckPoint.TotalItems;
if (this.CheckPointStageCallback(this))
{
return;
}
try
{
this.Repository.RebuildIndex <ExportUser>(x => x.Id, true);
this.Repository.RebuildIndex <ExportUserPortal>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportAspnetUser>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportAspnetMembership>(x => x.ReferenceId);
this.Repository.RebuildIndex <ExportUserAuthentication>(x => x.ReferenceId);
var portalId = importJob.PortalId;
var dataProvider = DotNetNuke.Data.DataProvider.Instance();
using (var table = new DataTable("Users"))
{
// must create the columns from scratch with each iteration
table.Columns.AddRange(
UsersDatasetColumns.Select(column => new DataColumn(column.Item1, column.Item2)).ToArray());
while (totalUsersImported < totalUsersToBeProcessed)
{
if (this.CheckCancelled(importJob))
{
return;
}
var users =
this.Repository.GetAllItems <ExportUser>(null, true, pageIndex * pageSize, pageSize).ToList();
var tempAspUserCount = 0;
var tempAspMembershipCount = 0;
var tempUserPortalCount = 0;
var tempUserAuthenticationCount = 0;
try
{
foreach (var user in users)
{
if (this.CheckCancelled(importJob))
{
return;
}
var row = table.NewRow();
var userPortal = this.Repository.GetRelatedItems <ExportUserPortal>(user.Id).FirstOrDefault();
var userAuthentication = this.Repository.GetRelatedItems <ExportUserAuthentication>(user.Id).FirstOrDefault();
// Aspnet Users and Membership
var aspNetUser = this.Repository.GetRelatedItems <ExportAspnetUser>(user.Id).FirstOrDefault();
var aspnetMembership = aspNetUser != null
? this.Repository.GetRelatedItems <ExportAspnetMembership>(aspNetUser.Id).FirstOrDefault()
: null;
row["PortalId"] = portalId;
row["Username"] = user.Username;
row["FirstName"] = string.IsNullOrEmpty(user.FirstName) ? string.Empty : user.FirstName;
row["LastName"] = string.IsNullOrEmpty(user.LastName) ? string.Empty : user.LastName;
row["AffiliateId"] = dataProvider.GetNull(user.AffiliateId);
row["IsSuperUser"] = user.IsSuperUser;
row["Email"] = user.Email;
row["DisplayName"] = string.IsNullOrEmpty(user.DisplayName) ? string.Empty : user.DisplayName;
row["UpdatePassword"] = user.UpdatePassword;
row["CreatedByUserID"] = Util.GetUserIdByName(importJob, user.CreatedByUserId, user.CreatedByUserName);
row["LastIPAddress"] = dataProvider.GetNull(user.LastIpAddress);
row["PasswordResetToken"] = dataProvider.GetNull(user.PasswordResetToken);
row["PasswordResetExpiration"] = dataProvider.GetNull(user.PasswordResetExpiration);
row["LastModifiedByUserID"] = Util.GetUserIdByName(importJob, user.LastModifiedByUserId, user.LastModifiedByUserName);
if (userPortal != null)
{
tempUserPortalCount += 1;
row["Authorised"] = userPortal.Authorised;
row["VanityUrl"] = userPortal.VanityUrl;
row["RefreshRoles"] = userPortal.RefreshRoles;
row["IsDeleted"] = userPortal.IsDeleted;
}
else
{
row["Authorised"] = DBNull.Value;
row["VanityUrl"] = DBNull.Value;
row["RefreshRoles"] = DBNull.Value;
row["IsDeleted"] = DBNull.Value;
}
if (userAuthentication != null)
{
tempUserAuthenticationCount += 1;
row["AuthenticationType"] = userAuthentication?.AuthenticationType;
row["AuthenticationToken"] = userAuthentication?.AuthenticationToken;
}
else
{
row["AuthenticationType"] = DBNull.Value;
row["AuthenticationToken"] = DBNull.Value;
}
if (aspNetUser != null)
{
tempAspUserCount += 1;
row["ApplicationId"] = this.GetApplicationId();
row["AspUserId"] = aspNetUser.UserId;
row["MobileAlias"] = aspNetUser.MobileAlias;
row["IsAnonymous"] = aspNetUser.IsAnonymous;
if (aspnetMembership != null)
{
tempAspMembershipCount += 1;
row["Password"] = string.IsNullOrEmpty(aspnetMembership.Password) ? string.Empty : aspnetMembership.Password;
row["PasswordFormat"] = aspnetMembership.PasswordFormat;
row["PasswordSalt"] = aspnetMembership.PasswordSalt;
row["MobilePIN"] = aspnetMembership.MobilePin;
row["PasswordQuestion"] = aspnetMembership.PasswordQuestion;
row["PasswordAnswer"] = aspnetMembership.PasswordAnswer;
row["IsApproved"] = aspnetMembership.IsApproved;
row["IsLockedOut"] = aspnetMembership.IsLockedOut;
row["FailedPasswordAttemptCount"] = aspnetMembership.FailedPasswordAttemptCount;
row["FailedPasswordAnswerAttemptCount"] = aspnetMembership.FailedPasswordAnswerAttemptCount;
row["Comment"] = aspnetMembership.Comment;
}
}
else
{
row["ApplicationId"] = DBNull.Value;
row["AspUserId"] = DBNull.Value;
row["MobileAlias"] = DBNull.Value;
row["IsAnonymous"] = DBNull.Value;
row["Password"] = DBNull.Value;
row["PasswordFormat"] = DBNull.Value;
row["PasswordSalt"] = DBNull.Value;
row["MobilePIN"] = DBNull.Value;
row["PasswordQuestion"] = DBNull.Value;
row["PasswordAnswer"] = DBNull.Value;
row["IsApproved"] = DBNull.Value;
row["IsLockedOut"] = DBNull.Value;
row["FailedPasswordAttemptCount"] = DBNull.Value;
row["FailedPasswordAnswerAttemptCount"] = DBNull.Value;
row["Comment"] = DBNull.Value;
}
table.Rows.Add(row);
}
var overwrite = importDto.CollisionResolution == CollisionResolution.Overwrite;
// Bulk insert the data in DB
DotNetNuke.Data.DataProvider.Instance()
.BulkInsert("ExportImport_AddUpdateUsersBulk", "@DataTable", table, new Dictionary <string, object> {
{ "Overwrite", overwrite }
});
totalUsersImported += users.Count;
totalAspnetUserImported += tempAspUserCount;
totalAspnetMembershipImported += tempAspMembershipCount;
totalPortalsImported += tempUserPortalCount;
totalUserAuthenticationCount += tempUserAuthenticationCount;
this.CheckPoint.ProcessedItems += users.Count;
}
catch (Exception ex)
{
this.Result.AddLogEntry($"Importing Users from {pageIndex * pageSize} to {(pageIndex * pageSize) + pageSize} exception", ex.Message, ReportLevel.Error);
}
table.Rows.Clear();
pageIndex++;
this.CheckPoint.Progress = this.CheckPoint.ProcessedItems * 100.0 / totalUsers;
this.CheckPoint.Stage++;
this.CheckPoint.StageData = null;
if (this.CheckPointStageCallback(this))
{
return;
}
}
}
this.CheckPoint.Completed = true;
this.CheckPoint.Progress = 100;
}
finally
{
this.CheckPointStageCallback(this);
this.Result.AddSummary("Imported Users", totalUsersImported.ToString());
this.Result.AddSummary("Imported User Portals", totalPortalsImported.ToString());
this.Result.AddSummary("Import User Authentications", totalUserAuthenticationCount.ToString());
this.Result.AddSummary("Imported Aspnet Users", totalAspnetUserImported.ToString());
this.Result.AddSummary("Imported Aspnet Memberships", totalAspnetMembershipImported.ToString());
}
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
if (CheckCancelled(importJob) || CheckPoint.Stage >= 1 || CheckPoint.Completed || CheckPointStageCallback(this))
{
return;
}
var workflowManager = WorkflowManager.Instance;
var workflowStateManager = WorkflowStateManager.Instance;
var portalId = importJob.PortalId;
var importWorkflows = Repository.GetAllItems <ExportWorkflow>().ToList();
var existWorkflows = workflowManager.GetWorkflows(portalId).ToList();
var defaultTabWorkflowId = importWorkflows.FirstOrDefault(w => w.IsDefault)?.WorkflowID ?? 1;
CheckPoint.TotalItems = CheckPoint.TotalItems <= 0 ? importWorkflows.Count : CheckPoint.TotalItems;
#region importing workflows
foreach (var importWorkflow in importWorkflows)
{
var workflow = existWorkflows.FirstOrDefault(w => w.WorkflowName == importWorkflow.WorkflowName);
if (workflow != null)
{
if (!importWorkflow.IsSystem && importDto.CollisionResolution == CollisionResolution.Overwrite)
{
if (workflow.Description != importWorkflow.Description ||
workflow.WorkflowKey != importWorkflow.WorkflowKey)
{
workflow.Description = importWorkflow.Description;
workflow.WorkflowKey = importWorkflow.WorkflowKey;
workflowManager.UpdateWorkflow(workflow);
Result.AddLogEntry("Updated workflow", workflow.WorkflowName);
}
}
}
else
{
workflow = new Workflow
{
PortalID = portalId,
WorkflowName = importWorkflow.WorkflowName,
Description = importWorkflow.Description,
WorkflowKey = importWorkflow.WorkflowKey,
};
workflowManager.AddWorkflow(workflow);
Result.AddLogEntry("Added workflow", workflow.WorkflowName);
if (importWorkflow.WorkflowID == defaultTabWorkflowId)
{
TabWorkflowSettings.Instance.SetDefaultTabWorkflowId(portalId, workflow.WorkflowID);
}
}
importWorkflow.LocalId = workflow.WorkflowID;
#region importing workflow states
var importStates = Repository.GetRelatedItems <ExportWorkflowState>(importWorkflow.Id).ToList();
foreach (var importState in importStates)
{
var workflowState = workflow.States.FirstOrDefault(s => s.StateName == importState.StateName);
if (workflowState != null)
{
if (!workflowState.IsSystem)
{
workflowState.Order = importState.Order;
workflowState.IsSystem = false;
workflowState.SendNotification = importState.SendNotification;
workflowState.SendNotificationToAdministrators = importState.SendNotificationToAdministrators;
workflowStateManager.UpdateWorkflowState(workflowState);
Result.AddLogEntry("Updated workflow state", workflowState.StateID.ToString());
}
}
else
{
workflowState = new WorkflowState
{
StateName = importState.StateName,
WorkflowID = workflow.WorkflowID,
Order = importState.Order,
IsSystem = importState.IsSystem,
SendNotification = importState.SendNotification,
SendNotificationToAdministrators = importState.SendNotificationToAdministrators
};
WorkflowStateManager.Instance.AddWorkflowState(workflowState);
Result.AddLogEntry("Added workflow state", workflowState.StateID.ToString());
}
importState.LocalId = workflowState.StateID;
#region importin permissions
if (!workflowState.IsSystem)
{
var importPermissions = Repository.GetRelatedItems <ExportWorkflowStatePermission>(importState.Id).ToList();
foreach (var importPermission in importPermissions)
{
var permissionId = DataProvider.Instance().GetPermissionId(
importPermission.PermissionCode, importPermission.PermissionKey, importPermission.PermissionName);
if (permissionId != null)
{
var noRole = Convert.ToInt32(Globals.glbRoleNothing);
var userId = UserController.GetUserByName(importDto.PortalId, importPermission.Username)?.UserID;
var roleId = Util.GetRoleIdByName(importDto.PortalId, importPermission.RoleID ?? noRole, importPermission.RoleName);
var permission = new WorkflowStatePermission
{
PermissionID = permissionId ?? -1,
StateID = workflowState.StateID,
RoleID = noRole,
UserID = -1,
AllowAccess = importPermission.AllowAccess,
//TODO: ModuleDefID = ??? what value to set here ?
};
if (importPermission.UserID != null && importPermission.UserID > 0 && !string.IsNullOrEmpty(importPermission.Username))
{
if (userId == null)
{
Result.AddLogEntry("Couldn't add tab permission; User is undefined!",
$"{importPermission.PermissionKey} - {importPermission.PermissionID}", ReportLevel.Warn);
continue;
}
permission.UserID = userId.Value;
}
if (importPermission.RoleID != null && importPermission.RoleID > noRole && !string.IsNullOrEmpty(importPermission.RoleName))
{
if (roleId == null)
{
Result.AddLogEntry("Couldn't add tab permission; Role is undefined!",
$"{importPermission.PermissionKey} - {importPermission.PermissionID}", ReportLevel.Warn);
continue;
}
permission.RoleID = roleId.Value;
}
try
{
var existingPermissions = workflowStateManager.GetWorkflowStatePermissionByState(workflowState.StateID);
var local = existingPermissions.FirstOrDefault(
x => x.PermissionCode == importPermission.PermissionCode && x.PermissionKey == importPermission.PermissionKey &&
x.PermissionName.Equals(importPermission.PermissionName, StringComparison.InvariantCultureIgnoreCase) &&
x.RoleID == roleId && x.UserID == userId);
if (local == null)
{
workflowStateManager.AddWorkflowStatePermission(permission, -1);
importPermission.LocalId = permission.WorkflowStatePermissionID;
Result.AddLogEntry("Added workflow state permission",
permission.WorkflowStatePermissionID.ToString());
}
else
{
importPermission.LocalId = local.WorkflowStatePermissionID;
}
}
catch (Exception ex)
{
Result.AddLogEntry("Exception adding workflow state permission", ex.Message, ReportLevel.Error);
}
}
}
}
#endregion
}
#endregion
Repository.UpdateItems(importStates);
Result.AddSummary("Imported Workflow", importWorkflows.Count.ToString());
CheckPoint.ProcessedItems++;
CheckPointStageCallback(this); // no need to return; very small amount of data processed
}
#endregion
Repository.UpdateItems(importWorkflows);
CheckPoint.Stage++;
CheckPoint.StageData = null;
CheckPoint.Progress = 100;
CheckPoint.TotalItems = importWorkflows.Count;
CheckPoint.ProcessedItems = importWorkflows.Count;
CheckPointStageCallback(this);
}
public override void ExportData(ExportImportJob exportJob, ExportDto exportDto)
{
if (CheckCancelled(exportJob))
{
return;
}
//Skip the export if all the folders have been processed already.
if (CheckPoint.Stage >= 1)
{
return;
}
//Create Zip File to hold files
var skip = GetCurrentSkip();
var currentIndex = skip;
var totalFolderExported = 0;
var totalFolderPermissionsExported = 0;
var totalFilesExported = 0;
var portalId = exportJob.PortalId;
try
{
var assetsFile = string.Format(_assetsFolder, exportJob.Directory.TrimEnd('\\').TrimEnd('/'));
if (CheckPoint.Stage == 0)
{
var fromDate = (exportDto.FromDateUtc ?? Constants.MinDbTime).ToLocalTime();
var toDate = exportDto.ToDateUtc.ToLocalTime();
var portal = PortalController.Instance.GetPortal(portalId);
var folders =
CBO.FillCollection <ExportFolder>(DataProvider.Instance()
.GetFolders(portalId, toDate, fromDate)).ToList();
var totalFolders = folders.Any() ? folders.Count : 0;
folders = folders.Skip(skip).ToList();
//Update the total items count in the check points. This should be updated only once.
CheckPoint.TotalItems = CheckPoint.TotalItems <= 0 ? totalFolders : CheckPoint.TotalItems;
CheckPoint.ProcessedItems = skip;
CheckPoint.Progress = CheckPoint.TotalItems > 0 ? skip * 100.0 / CheckPoint.TotalItems : 0;
if (CheckPointStageCallback(this))
{
return;
}
using (var zipArchive = CompressionUtil.OpenCreate(assetsFile))
{
foreach (var folder in folders)
{
if (CheckCancelled(exportJob))
{
break;
}
var isUserFolder = false;
var files =
CBO.FillCollection <ExportFile>(
DataProvider.Instance()
.GetFiles(portalId, folder.FolderId, toDate, fromDate)).Where(x => x.Extension != Constants.TemplatesExtension).ToList();
int?userId;
if (IsUserFolder(folder.FolderPath, out userId))
{
isUserFolder = true;
folder.UserId = userId;
folder.Username =
UserController.GetUserById(portalId, Convert.ToInt32(userId))?.Username;
}
if (folder.ParentId != null && folder.ParentId > 0)
{
//If parent id exists then change the parent folder id to parent id.
folder.ParentId =
Repository.GetItem <ExportFolder>(
x => x.FolderId == Convert.ToInt32(folder.ParentId))?.Id;
}
Repository.CreateItem(folder, null);
totalFolderExported++;
//Include permissions only if IncludePermissions=true
if (exportDto.IncludePermissions)
{
var permissions =
CBO.FillCollection <ExportFolderPermission>(DataProvider.Instance()
.GetFolderPermissionsByPath(portalId, folder.FolderPath, toDate, fromDate));
Repository.CreateItems(permissions, folder.Id);
totalFolderPermissionsExported += permissions.Count;
}
Repository.CreateItems(files, folder.Id);
totalFilesExported += files.Count;
var folderOffset = portal.HomeDirectoryMapPath.Length +
(portal.HomeDirectoryMapPath.EndsWith("\\") ? 0 : 1);
if (folder.StorageLocation != (int)FolderController.StorageLocationTypes.DatabaseSecure)
{
CompressionUtil.AddFilesToArchive(zipArchive, files.Select(file => portal.HomeDirectoryMapPath + folder.FolderPath + GetActualFileName(file)),
folderOffset, isUserFolder ? "TempUsers" : null);
}
CheckPoint.ProcessedItems++;
CheckPoint.Progress = CheckPoint.ProcessedItems * 100.0 / totalFolders;
CheckPoint.StageData = null;
currentIndex++;
//After every 10 items, call the checkpoint stage. This is to avoid too many frequent updates to DB.
if (currentIndex % 10 == 0 && CheckPointStageCallback(this))
{
return;
}
Repository.RebuildIndex <ExportFolder>(x => x.Id, true);
Repository.RebuildIndex <ExportFolder>(x => x.UserId);
Repository.RebuildIndex <ExportFile>(x => x.ReferenceId);
}
}
CheckPoint.Completed = true;
CheckPoint.Stage++;
currentIndex = 0;
CheckPoint.Progress = 100;
}
}
finally
{
CheckPoint.StageData = currentIndex > 0 ? JsonConvert.SerializeObject(new { skip = currentIndex }) : null;
CheckPointStageCallback(this);
Result.AddSummary("Exported Folders", totalFolderExported.ToString());
Result.AddSummary("Exported Folder Permissions", totalFolderPermissionsExported.ToString());
Result.AddSummary("Exported Files", totalFilesExported.ToString());
}
}
private void ProcessFiles(ExportImportJob importJob, ImportDto importDto, ExportFile file, IEnumerable <ExportFile> localFiles)
{
if (file == null)
{
return;
}
var existingFile = localFiles.FirstOrDefault(x => x.FileName == file.FileName);
var isUpdate = false;
if (existingFile != null)
{
switch (importDto.CollisionResolution)
{
case CollisionResolution.Overwrite:
isUpdate = true;
break;
case CollisionResolution.Ignore:
return;
default:
throw new ArgumentOutOfRangeException(importDto.CollisionResolution.ToString());
}
}
if (isUpdate)
{
var modifiedBy = Util.GetUserIdByName(importJob, file.LastModifiedByUserId, file.LastModifiedByUserName);
file.FileId = existingFile.FileId;
DotNetNuke.Data.DataProvider.Instance()
.UpdateFile(existingFile.FileId, file.VersionGuid, file.FileName, file.Extension, file.Size,
file.Width ?? Null.NullInteger, file.Height ?? Null.NullInteger, file.ContentType, file.FolderId,
modifiedBy, file.Sha1Hash, DateUtils.GetDatabaseLocalTime(), file.Title, file.Description,
file.StartDate, file.EndDate ?? Null.NullDate, file.EnablePublishPeriod,
existingFile.ContentItemId ?? Null.NullInteger);
if ((file.Content != null && existingFile.Content == null) ||
(existingFile.Content != null && file.Content == null) ||
(file.Content != null && existingFile.Content != null &&
file.Content.SequenceEqual(existingFile.Content)))
{
DotNetNuke.Data.DataProvider.Instance().UpdateFileContent(file.FileId, file.Content);
}
}
else
{
var createdBy = Util.GetUserIdByName(importJob, file.CreatedByUserId, file.CreatedByUserName);
file.FileId = DotNetNuke.Data.DataProvider.Instance()
.AddFile(importJob.PortalId, Guid.NewGuid(), file.VersionGuid, file.FileName, file.Extension,
file.Size,
file.Width ?? Null.NullInteger, file.Height ?? Null.NullInteger, file.ContentType, file.Folder,
file.FolderId,
createdBy, file.Sha1Hash, DateUtils.GetDatabaseLocalTime(), file.Title, file.Description,
file.StartDate, file.EndDate ?? Null.NullDate, file.EnablePublishPeriod,
//file.ContentItemId ?? Null.NullInteger);--If we keep it we will see FK_PK relationship errors.
Null.NullInteger);
if (file.Content != null)
{
DotNetNuke.Data.DataProvider.Instance().UpdateFileContent(file.FileId, file.Content);
}
}
}
private void ProcessFolderPermission(ExportImportJob importJob, ImportDto importDto,
ExportFolderPermission folderPermission, IEnumerable <ExportFolderPermission> localPermissions)
{
var portalId = importJob.PortalId;
var noRole = Convert.ToInt32(Globals.glbRoleNothing);
if (folderPermission == null)
{
return;
}
var roleId = Util.GetRoleIdByName(portalId, folderPermission.RoleId ?? noRole, folderPermission.RoleName);
var userId = UserController.GetUserByName(portalId, folderPermission.Username)?.UserID;
var existingFolderPermission = localPermissions.FirstOrDefault(
x =>
(x.FolderPath == folderPermission.FolderPath ||
(string.IsNullOrEmpty(x.FolderPath) && string.IsNullOrEmpty(folderPermission.FolderPath))) &&
x.PermissionCode == folderPermission.PermissionCode && x.PermissionKey == folderPermission.PermissionKey &&
x.PermissionName.Equals(folderPermission.PermissionName, StringComparison.InvariantCultureIgnoreCase) &&
x.RoleId == roleId && x.UserId == userId);
var isUpdate = false;
if (existingFolderPermission != null)
{
switch (importDto.CollisionResolution)
{
case CollisionResolution.Overwrite:
isUpdate = true;
break;
case CollisionResolution.Ignore:
return;
default:
throw new ArgumentOutOfRangeException(importDto.CollisionResolution.ToString());
}
}
if (isUpdate)
{
var modifiedBy = Util.GetUserIdByName(importJob, folderPermission.LastModifiedByUserId,
folderPermission.LastModifiedByUserName);
DotNetNuke.Data.DataProvider.Instance()
.UpdateFolderPermission(existingFolderPermission.FolderPermissionId, folderPermission.FolderId,
existingFolderPermission.PermissionId, existingFolderPermission.RoleId ?? Convert.ToInt32(Globals.glbRoleNothing),
folderPermission.AllowAccess, existingFolderPermission.UserId ?? Null.NullInteger, modifiedBy);
folderPermission.FolderPermissionId = existingFolderPermission.FolderPermissionId;
}
else
{
var permissionId = DataProvider.Instance()
.GetPermissionId(folderPermission.PermissionCode, folderPermission.PermissionKey,
folderPermission.PermissionName);
if (permissionId != null)
{
folderPermission.PermissionId = Convert.ToInt32(permissionId);
if (folderPermission.UserId != null && folderPermission.UserId > 0 && !string.IsNullOrEmpty(folderPermission.Username))
{
folderPermission.UserId = userId;
if (folderPermission.UserId == null)
{
return;
}
}
if (folderPermission.RoleId != null && folderPermission.RoleId > noRole && !string.IsNullOrEmpty(folderPermission.RoleName))
{
folderPermission.RoleId = roleId;
if (folderPermission.RoleId == null)
{
return;
}
}
var createdBy = Util.GetUserIdByName(importJob, folderPermission.CreatedByUserId,
folderPermission.CreatedByUserName);
folderPermission.FolderPermissionId = DotNetNuke.Data.DataProvider.Instance()
.AddFolderPermission(folderPermission.FolderId, folderPermission.PermissionId,
folderPermission.RoleId ?? noRole, folderPermission.AllowAccess,
folderPermission.UserId ?? Null.NullInteger, createdBy);
}
}
folderPermission.LocalId = folderPermission.FolderPermissionId;
}
private bool ProcessFolder(ExportImportJob importJob, ImportDto importDto, ExportFolder folder)
{
var portalId = importJob.PortalId;
if (folder == null)
{
return(false);
}
var existingFolder = CBO.FillObject <ExportFolder>(DotNetNuke.Data.DataProvider.Instance().GetFolder(portalId, folder.FolderPath ?? ""));
var isUpdate = false;
var modifiedBy = Util.GetUserIdByName(importJob, folder.LastModifiedByUserId, folder.LastModifiedByUserName);
if (existingFolder != null)
{
switch (importDto.CollisionResolution)
{
case CollisionResolution.Overwrite:
isUpdate = true;
break;
case CollisionResolution.Ignore:
return(false);
default:
throw new ArgumentOutOfRangeException(importDto.CollisionResolution.ToString());
}
}
folder.FolderPath = string.IsNullOrEmpty(folder.FolderPath) ? "" : folder.FolderPath;
var folderMapping = FolderMappingController.Instance.GetFolderMapping(portalId, folder.FolderMappingName);
if (folderMapping == null)
{
return(false);
}
var workFlowId = GetLocalWorkFlowId(folder.WorkflowId);
if (isUpdate)
{
Util.FixDateTime(existingFolder);
DotNetNuke.Data.DataProvider.Instance()
.UpdateFolder(importJob.PortalId, folder.VersionGuid, existingFolder.FolderId, folder.FolderPath,
folder.StorageLocation, folder.MappedPath, folder.IsProtected, folder.IsCached,
DateUtils.GetDatabaseLocalTime(), modifiedBy, folderMapping.FolderMappingID, folder.IsVersioned,
workFlowId, existingFolder.ParentId ?? Null.NullInteger);
folder.FolderId = existingFolder.FolderId;
if (folder.UserId != null && folder.UserId > 0 && !string.IsNullOrEmpty(folder.Username))
{
SyncUserFolder(importJob.PortalId, folder);
}
}
else
{
folder.FolderMappingId = folderMapping.FolderMappingID;
var createdBy = Util.GetUserIdByName(importJob, folder.CreatedByUserId, folder.CreatedByUserName);
if (folder.ParentId != null && folder.ParentId > 0)
{
//Find the previously created parent folder id.
folder.ParentId = CBO.FillObject <ExportFolder>(DotNetNuke.Data.DataProvider.Instance().GetFolder(portalId, folder.ParentFolderPath ?? ""))?.FolderId;
}
//ignore folders which start with Users but are not user folders.
if (!folder.FolderPath.StartsWith(DefaultUsersFoldersPath))
{
folder.FolderId = DotNetNuke.Data.DataProvider.Instance()
.AddFolder(importJob.PortalId, Guid.NewGuid(), folder.VersionGuid, folder.FolderPath,
folder.MappedPath, folder.StorageLocation, folder.IsProtected, folder.IsCached,
DateUtils.GetDatabaseLocalTime(),
createdBy, folderMapping.FolderMappingID, folder.IsVersioned, workFlowId,
folder.ParentId ?? Null.NullInteger);
}
//Case when the folder is a user folder.
else if (folder.UserId != null && folder.UserId > 0 && !string.IsNullOrEmpty(folder.Username))
{
var userInfo = UserController.GetUserByName(portalId, folder.Username);
if (userInfo == null)
{
folder.FolderId = 0;
return(false);
}
userInfo.IsSuperUser = false;
var newFolder = FolderManager.Instance.GetUserFolder(userInfo);
folder.FolderId = newFolder.FolderID;
folder.FolderPath = newFolder.FolderPath;
SyncUserFolder(importJob.PortalId, folder);
return(true);
}
else
{
folder.FolderId = 0;
return(false);
}
}
return(true);
}
public override void ImportData(ExportImportJob importJob, ImportDto importDto)
{
if (CheckCancelled(importJob))
{
return;
}
//Stage 1: Portals files unzipped.
//Stage 2: All folders and files imported.
//Stage 3: Synchronization completed.
//Skip the export if all the folders have been processed already.
if (CheckPoint.Stage >= 2 || CheckPoint.Completed)
{
return;
}
var totalFolderImported = 0;
var totalFolderPermissionsImported = 0;
var totalFilesImported = 0;
var skip = GetCurrentSkip();
var currentIndex = skip;
var portalId = importJob.PortalId;
var portal = PortalController.Instance.GetPortal(portalId);
var assetsFile = string.Format(_assetsFolder, importJob.Directory.TrimEnd('\\').TrimEnd('/'));
var userFolderPath = string.Format(UsersAssetsTempFolder, portal.HomeDirectoryMapPath.TrimEnd('\\'));
if (CheckPoint.Stage == 0)
{
if (!File.Exists(assetsFile))
{
Result.AddLogEntry("AssetsFileNotFound", "Assets file not found. Skipping assets import",
ReportLevel.Warn);
CheckPoint.Completed = true;
CheckPointStageCallback(this);
}
else
{
CompressionUtil.UnZipArchive(assetsFile, portal.HomeDirectoryMapPath,
importDto.CollisionResolution == CollisionResolution.Overwrite);
//Stage 1: Once unzipping of portal files is completed.
CheckPoint.Stage++;
CheckPoint.StageData = null;
CheckPoint.Progress = 10;
if (CheckPointStageCallback(this))
{
return;
}
}
}
if (CheckPoint.Stage == 1)
{
try
{
//Stage 2 starts
var sourceFolders = Repository.GetAllItems <ExportFolder>(x => x.CreatedOnDate, true, skip).ToList();
var totalFolders = sourceFolders.Any() ? sourceFolders.Count : 0;
//Update the total items count in the check points. This should be updated only once.
CheckPoint.TotalItems = CheckPoint.TotalItems <= 0 ? totalFolders : CheckPoint.TotalItems;
if (CheckPointStageCallback(this))
{
return;
}
foreach (var sourceFolder in sourceFolders)
{
if (CheckCancelled(importJob))
{
break;
}
// PROCESS FOLDERS
//Create new or update existing folder
if (ProcessFolder(importJob, importDto, sourceFolder))
{
totalFolderImported++;
//Include permissions only if permissions were exported in package.
if (importDto.ExportDto.IncludePermissions)
{
// PROCESS FOLDER PERMISSIONS
var sourceFolderPermissions =
Repository.GetRelatedItems <ExportFolderPermission>(sourceFolder.Id).ToList();
//Replace folderId for each permission with new one.
sourceFolderPermissions.ForEach(x =>
{
x.FolderId = Convert.ToInt32(sourceFolder.FolderId);
x.FolderPath = sourceFolder.FolderPath;
});
// PROCESS FOLDER PERMISSIONS
//File local files in the system related to the folder path.
var localPermissions =
CBO.FillCollection <ExportFolderPermission>(DataProvider.Instance()
.GetFolderPermissionsByPath(portalId, sourceFolder.FolderPath,
DateUtils.GetDatabaseUtcTime().AddYears(1), null));
foreach (var folderPermission in sourceFolderPermissions)
{
ProcessFolderPermission(importJob, importDto, folderPermission,
localPermissions);
}
totalFolderPermissionsImported += sourceFolderPermissions.Count;
}
// PROCESS FILES
var sourceFiles =
Repository.GetRelatedItems <ExportFile>(sourceFolder.Id).ToList();
//Replace folderId for each file with new one.
sourceFiles.ForEach(x =>
{
x.FolderId = Convert.ToInt32(sourceFolder.FolderId);
x.Folder = sourceFolder.FolderPath;
});
//File local files in the system related to the folder
var localFiles =
CBO.FillCollection <ExportFile>(DataProvider.Instance()
.GetFiles(portalId, sourceFolder.FolderId,
DateUtils.GetDatabaseUtcTime().AddYears(1), null));
foreach (var file in sourceFiles)
{
ProcessFiles(importJob, importDto, file, localFiles);
}
totalFilesImported += sourceFiles.Count;
}
currentIndex++;
CheckPoint.ProcessedItems++;
CheckPoint.Progress = 10 + CheckPoint.ProcessedItems * 90.0 / totalFolders;
//After every 10 items, call the checkpoint stage. This is to avoid too many frequent updates to DB.
if (currentIndex % 10 == 0 && CheckPointStageCallback(this))
{
return;
}
}
currentIndex = 0;
CheckPoint.Completed = true;
CheckPoint.Stage++;
CheckPoint.Progress = 100;
}
finally
{
CheckPoint.StageData = currentIndex > 0
? JsonConvert.SerializeObject(new { skip = currentIndex })
: null;
CheckPointStageCallback(this);
Result.AddSummary("Imported Folders", totalFolderImported.ToString());
Result.AddSummary("Imported Folder Permissions", totalFolderPermissionsImported.ToString());
Result.AddSummary("Imported Files", totalFilesImported.ToString());
if (Directory.Exists(userFolderPath) && currentIndex == 0)
{
Directory.Delete(userFolderPath, true);
}
}
}
}
private static void RemoveTokenFromCache(ExportImportJob job)
{
CachingProvider.Instance().Remove(Util.GetExpImpJobCacheKey(job));
}
private static void AddJobToCache(ExportImportJob job)
{
CachingProvider.Instance().Insert(Util.GetExpImpJobCacheKey(job), job);
}
/// <summary>Runs the import job.</summary>
/// <param name="importJob">The import job.</param>
/// <param name="result">The result.</param>
/// <param name="scheduleHistoryItem">The schedule history item.</param>
public void Import(ExportImportJob importJob, ExportImportResult result, ScheduleHistoryItem scheduleHistoryItem)
{
scheduleHistoryItem.AddLogNote($"<br/><b>SITE IMPORT Started. JOB #{importJob.JobId}</b>");
this.timeoutSeconds = GetTimeoutPerSlot();
var importDto = JsonConvert.DeserializeObject <ImportDto>(importJob.JobObject);
if (importDto == null)
{
importJob.CompletedOnDate = DateUtils.GetDatabaseUtcTime();
importJob.JobStatus = JobStatus.Failed;
return;
}
var dbName = Path.Combine(ExportFolder, importJob.Directory, Constants.ExportDbName);
var finfo = new FileInfo(dbName);
if (!finfo.Exists)
{
DoUnPacking(importJob);
finfo = new FileInfo(dbName);
}
if (!finfo.Exists)
{
scheduleHistoryItem.AddLogNote("<br/>Import file not found. Name: " + dbName);
importJob.CompletedOnDate = DateUtils.GetDatabaseUtcTime();
importJob.JobStatus = JobStatus.Failed;
return;
}
using (var ctx = new ExportImportRepository(dbName))
{
var exportedDto = ctx.GetSingleItem <ExportDto>();
var exportVersion = new Version(exportedDto.SchemaVersion);
var importVersion = new Version(importDto.SchemaVersion);
if (importVersion < exportVersion)
{
importJob.CompletedOnDate = DateUtils.GetDatabaseUtcTime();
importJob.JobStatus = JobStatus.Failed;
scheduleHistoryItem.AddLogNote("Import NOT Possible");
var msg =
$"Exported version ({exportedDto.SchemaVersion}) is newer than import engine version ({importDto.SchemaVersion})";
result.AddSummary("Import NOT Possible", msg);
return;
}
var checkpoints = EntitiesController.Instance.GetJobChekpoints(importJob.JobId);
if (checkpoints.Count == 0)
{
result.AddSummary("Starting Importing Repository", finfo.Name);
result.AddSummary("Importing File Size", Util.FormatSize(finfo.Length));
CleanupDatabaseIfDirty(ctx);
}
else
{
result.AddSummary("Resuming Importing Repository", finfo.Name);
}
var implementors = Util.GetPortableImplementors().ToList();
var parentServices = implementors.Where(imp => string.IsNullOrEmpty(imp.ParentCategory)).ToList();
importJob.Name = exportedDto.ExportName;
importJob.Description = exportedDto.ExportDescription;
importJob.JobStatus = JobStatus.InProgress;
// there must be one parent implementor at least for this to work
implementors = implementors.Except(parentServices).ToList();
var nextLevelServices = new List <BasePortableService>();
var includedItems = GetAllCategoriesToInclude(exportedDto, implementors);
scheduleHistoryItem.AddLogNote($"<br/><b>SITE IMPORT Preparing Check Points. JOB #{importJob.JobId}: {importJob.Name}</b>");
this.PrepareCheckPoints(importJob.JobId, parentServices, implementors, includedItems, checkpoints);
var firstIteration = true;
AddJobToCache(importJob);
do
{
foreach (var service in parentServices.OrderBy(x => x.Priority))
{
if (importJob.IsCancelled)
{
importJob.JobStatus = JobStatus.Cancelled;
break;
}
if (implementors.Count > 0)
{
// collect children for next iteration
var children =
implementors.Where(imp => service.Category.Equals(imp.ParentCategory, IgnoreCaseComp));
nextLevelServices.AddRange(children);
implementors = implementors.Except(nextLevelServices).ToList();
}
if ((firstIteration && includedItems.Any(x => x.Equals(service.Category, IgnoreCaseComp))) ||
(!firstIteration && includedItems.Any(x => x.Equals(service.ParentCategory, IgnoreCaseComp))))
{
var serviceAssembly = service.GetType().Assembly.GetName().Name;
service.Result = result;
service.Repository = ctx;
service.CheckCancelled = CheckCancelledCallBack;
service.CheckPointStageCallback = this.CheckpointCallback;
service.CheckPoint = checkpoints.FirstOrDefault(cp => cp.Category == service.Category && cp.AssemblyName == serviceAssembly)
?? new ExportImportChekpoint
{
JobId = importJob.JobId,
AssemblyName = serviceAssembly,
Category = service.Category,
Progress = 0,
StartDate = DateUtils.GetDatabaseUtcTime(),
};
if (service.CheckPoint.StartDate == Null.NullDate)
{
service.CheckPoint.StartDate = DateUtils.GetDatabaseUtcTime();
}
this.CheckpointCallback(service);
try
{
service.ImportData(importJob, importDto);
}
finally
{
this.AddLogsToDatabase(importJob.JobId, result.CompleteLog);
}
scheduleHistoryItem.AddLogNote("<br/>Imported: " + service.Category);
}
}
firstIteration = false;
parentServices = new List <BasePortableService>(nextLevelServices);
nextLevelServices.Clear();
if (implementors.Count > 0 && parentServices.Count == 0)
{
// WARN: this is a case where there is a broken parent-children hierarchy
// and/or there are BasePortableService implementations without a known parent.
parentServices = implementors;
implementors.Clear();
scheduleHistoryItem.AddLogNote(
"<br/><b>Orphaned services:</b> " + string.Join(",", parentServices.Select(x => x.Category)));
}
}while (parentServices.Count > 0 && !this.TimeIsUp);
RemoveTokenFromCache(importJob);
if (this.TimeIsUp)
{
result.AddSummary(
$"Job time slot ({this.timeoutSeconds} sec) expired",
"Job will resume in the next scheduler iteration");
}
else if (importJob.JobStatus == JobStatus.InProgress)
{
importJob.JobStatus = JobStatus.Successful;
if (importDto.ExportDto.IncludeContent)
{
PagesExportService.ResetContentsFlag(ctx);
}
}
}
}
