/// <summary>
/// Reload data.
/// </summary>
/// <param name="refreshSelection">Refresh selection</param>
public void ReloadData(bool refreshSelection)
{
bool singleSiteObject = SingleObject && Settings.SiteIsIncluded;
// Refresh selection
if (refreshSelection)
{
radExisting.Checked = singleSiteObject;
radNewSite.Checked = !singleSiteObject;
plcExistingSelection.Visible = !singleSiteObject;
plcNewSelection.Visible = !singleSiteObject && AllowExisting && (siteSelector.DropDownSingleSelect.Items.Count != 0);
plcNewSite.Visible = !singleSiteObject;
siteSelector.Enabled = singleSiteObject;
}
txtDomain.Enabled = radNewSite.Checked;
txtSiteDisplayName.Enabled = radNewSite.Checked;
txtSiteName.Enabled = radNewSite.Checked;
cultureElem.Enabled = radNewSite.Checked;
siteSelector.Enabled = !radNewSite.Checked;
DataTable table = ImportProvider.GetObjectsData(Settings, SiteInfo.OBJECT_TYPE, true);
if (!DataHelper.DataSourceIsEmpty(table))
{
// Get datarow
DataRow dr = table.Rows[0];
txtSiteDisplayName.Text = SiteDisplayName ?? dr["SiteDisplayName"].ToString();
txtDomain.Text = DomainName ?? dr["SiteDomainName"].ToString();
txtSiteName.Text = SiteName ?? dr["SiteName"].ToString();
}
}
private static void ImportObject(string packagePath, string userName)
{
string objectType = "";
int objectID = 0;
SiteImportSettings settings = new SiteImportSettings(UserInfoProvider.GetUserInfo(userName));
settings.UseAutomaticSiteForTranslation = true;
settings.LogSynchronization = true;
settings.WebsitePath = SystemContext.WebApplicationPhysicalPath;
settings.SourceFilePath = packagePath;
var obj = ObjectSelections(objectType);
var importObj = SingleObjectSelection(objectID, obj);
if (importObj.ObjectSiteID > 0)
{
settings.SiteId = importObj.ObjectSiteID;
settings.ExistingSite = true;
settings.SiteIsContentOnly = settings.SiteInfo.SiteIsContentOnly;
// Do not update site definition when restoring a single object
settings.SetSettings(ImportExportHelper.SETTINGS_UPDATE_SITE_DEFINITION, false);
}
ImportProvider.CreateTemporaryFiles(settings);
settings.LoadDefaultSelection();
ImportProvider.ImportObjectsData(settings);
}
// Create temporary files and preselect objects
private void CreateTemporaryFiles(object parameter)
{
var settngs = ImportSettings;
ImportProvider.CreateTemporaryFiles(settngs);
settngs.LoadDefaultSelection();
settngs.SavePersistent();
}
/// <summary>
/// Executes the model validation process.
/// </summary>
/// <param name="context">The compilation context.</param>
public void Execute(CompilationContext context)
{
var provider = new ImportProvider <IModelValidator>();
foreach (var validator in provider.GetImports())
{
validator.Validate(context.Model, context.Result);
}
}
/// <summary>
/// Executes the model validation process.
/// </summary>
/// <param name="context">The compilation context.</param>
public void Execute(CompilationContext context)
{
var provider = new ImportProvider<IModelValidator>();
foreach (var validator in provider.GetImports())
{
validator.Validate(context.Model, context.Result);
}
}
/// <summary>
/// Restores the single object.
/// </summary>
private void RestoreSingleObject(object parameter)
{
// Restore the entire content of the package
ImportProvider.CreateTemporaryFiles(ImportSettings);
ImportSettings.LoadDefaultSelection();
ImportProvider.ImportObjectsData(ImportSettings);
}
/// <summary>
/// Returns <c>true</c> if imported package contains site which is compatible with current version.
/// </summary>
private bool SiteIsSupported(SiteImportSettings settings)
{
DataTable table = ImportProvider.GetObjectsData(settings, SiteInfo.OBJECT_TYPE, true);
if ((table != null) && settings.IsLowerVersion("13.0"))
{
return DataHelper.GetBoolValue(table.Rows[0], "SiteIsContentOnly", false);
}
return true;
}
private void EnsureTemplateSelection()
{
try
{
var webPathMapper = Service.Resolve <IWebPathMapper>();
var path = webPathMapper.MapPath(BLANK_SITE_PATH);
if (!File.Exists(Path.Combine(path, "template.zip")))
{
siteDetails.StopProcessing = true;
pnlWrapper.Visible = false;
ShowError(GetString("NewSite.NoWebTemplate"));
return;
}
path = Path.Combine(path, ZipStorageProvider.GetZipFileName("template.zip"));
ImportSettings.SourceFilePath = path;
ImportSettings.TemporaryFilesPath = path;
ImportSettings.TemporaryFilesCreated = true;
ImportSettings.RefreshMacroSecurity = true;
ImportSettings.IsNewSite = true;
ImportProvider.CreateTemporaryFiles(ImportSettings);
// Import all, but only add new data
ImportSettings.ImportType = ImportTypeEnum.AllNonConflicting;
ImportSettings.ImportOnlyNewObjects = true;
ImportSettings.CopyFiles = false;
// Allow bulk inserts for faster import, web templates must be consistent enough to allow this without collisions
ImportSettings.AllowBulkInsert = true;
ltlScriptAfter.Text = ScriptHelper.GetScript($@"
var actDiv = document.getElementById('actDiv');
if (actDiv != null) {{
actDiv.style.display='block';
}}
var buttonsDiv = document.getElementById('buttonsDiv');
if (buttonsDiv != null) {{
buttonsDiv.disabled=true;
}}
BTN_Disable('{NextButton.ClientID}');
StartSelectionTimer();");
// Preselect objects asynchronously
ctrlAsyncSelection.RunAsync(SelectObjects, WindowsIdentity.GetCurrent());
}
catch (Exception ex)
{
SetErrorLabel(ex.Message);
}
}
/// <summary>
/// Executes the preprocessing process.
/// </summary>
/// <param name="context">The compilation context.</param>
public void Execute(CompilationContext context)
{
if (context == null || context.Compilation == null)
return;
// get local imports
var provider = new ImportProvider<IPreprocessor>(null);
var sorter = new PreprocessorSorter();
foreach (var preprocessor in sorter.Sort(provider.GetImports()))
{
context.Compilation = preprocessor.ProcessCompilation(context.Compilation);
}
}
// execute a given import action
static private void Import(ImportAction action, ImportPackage package, Action <int, string> log, dynamic context)
{
try {
// run dependencies
foreach (var dependency in action.Dependencies.Select(d => package[d]).Where(a => !(a ?? new ImportAction()).Executed))
{
try {
if (dependency != null)
{
Import(dependency, package, log, context);
}
} catch {
if (action.BreakOnError)
{
throw;
}
}
}
// run the action
log.Info("{0} started", action.Name);
Type providerType = Type.GetType(action.ProviderType);
ImportProvider provider = providerType != null
? Activator.CreateInstance(providerType) as ImportProvider
: null;
if (provider == null)
{
if (providerType == null)
{
throw new Exception(string.Format("Import action provider does not exist. '{0}'", action.ProviderType));
}
throw new Exception(string.Format("Invalid import action provider: '{0}'. ", action.ProviderType));
}
// perform the actions outlined in the instructions
provider.Import(action.Instructions, package.Data, log, context);
action.Executed = true; // Provide an indicator for other references, update the action executed to true.
log.Info("{0} completed", action.Name);
} catch (Exception aex) {
log.Error(aex.Message);
log.Debug(aex, "");
log.Info("{0} aborted", action.Name);
if (action.BreakOnError)
{
throw;
}
}
}
/// <summary>
/// Procedures which automatically imports the upgrade export package with all WebParts, Widgets, Reports and TimeZones.
/// </summary>
private static void UpgradeImportPackage()
{
// Import
try
{
RequestStockHelper.Remove("CurrentDomain", true);
var importSettings = new SiteImportSettings(MembershipContext.AuthenticatedUser)
{
DefaultProcessObjectType = ProcessObjectEnum.All,
SourceFilePath = mUpgradePackagePath,
WebsitePath = mWebsitePath
};
using (var context = new CMSActionContext())
{
context.DisableLogging();
context.CreateVersion = false;
context.LogIntegration = false;
ImportProvider.ImportObjectsData(importSettings);
// Regenerate time zones
TimeZoneInfoProvider.GenerateTimeZoneRules();
// Delete the files for separable modules which are not install and therefore not needed
DeleteWebPartsOfUninstalledModules();
ImportMetaFiles(Path.Combine(mWebsitePath, "App_Data\\CMSTemp\\Upgrade"));
}
}
catch (Exception ex)
{
EventLogProvider.LogException(EVENT_LOG_INFO, "Upgrade", ex);
}
finally
{
try
{
RefreshMacroSignatures();
EventLogProvider.LogInformation(EVENT_LOG_INFO, "Upgrade - Finish");
}
catch (Exception ex)
{
EventLogProvider.LogException(EVENT_LOG_INFO, "Upgrade", ex);
}
}
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (!RequestHelper.IsCallback())
{
if (Settings != null)
{
if (SelectedNodeValue != CMS.DocumentEngine.TreeNode.OBJECT_TYPE)
{
DataSet ds = ImportProvider.LoadObjects(Settings, SelectedNodeValue, SiteNode, selectionOnly: true);
// Bind grid view
gvObjects.Visible = true;
gvObjects.ObjectType = SelectedNodeValue;
gvObjects.Settings = Settings;
gvObjects.SiteObject = SiteNode;
gvObjects.DataSource = ds;
gvObjects.Bind();
gvTasks.Visible = true;
gvTasks.ObjectType = SelectedNodeValue;
gvTasks.Settings = Settings;
gvTasks.SiteObject = SiteNode;
gvTasks.DataSource = ds;
gvTasks.Bind();
}
else
{
gvObjects.Visible = false;
gvTasks.Visible = false;
}
// Reload settings control
if (settingsControl != null)
{
settingsControl.ReloadData();
}
}
pnlError.Visible = (lblError.Text != "");
// Save scrollbar position
mScrollPosition = ValidationHelper.GetString(Page.Request.Params["hdnDivScrollBar"], "0");
}
}
/// <summary>
/// Executes the preprocessing process.
/// </summary>
/// <param name="context">The compilation context.</param>
public void Execute(CompilationContext context)
{
if (context == null || context.Compilation == null)
{
return;
}
// get local imports
var provider = new ImportProvider <IPreprocessor>(null);
var sorter = new PreprocessorSorter();
foreach (var preprocessor in sorter.Sort(provider.GetImports()))
{
context.Compilation = preprocessor.ProcessCompilation(context.Compilation);
}
}
/// <summary>
/// Imports the license keys from package defined by <paramref name="settings"/>.
/// </summary>
private static void EnsureLicenseFromPackage(SiteImportSettings settings)
{
// Clone import settings so they aren't changed by license import process
SiteImportSettings settingsCopy;
using (var stream = new IOExceptions.MemoryStream())
{
var formatter = new BinaryFormatter();
formatter.Serialize(stream, settings);
stream.Position = 0;
settingsCopy = (SiteImportSettings)formatter.Deserialize(stream);
}
ImportProvider.ImportObjectType(settingsCopy, LicenseKeyInfo.OBJECT_TYPE, false, new TranslationHelper(), ProcessObjectEnum.Selected, new List <int>());
}
// Load imports lsit
private void LoadImports()
{
if (lstImports.Items.Count == 0)
{
List <string> files = null;
// Get import packages
try
{
files = ImportProvider.GetImportFilesList();
}
catch
{
// Show error and log exception
string path = ImportExportHelper.GetSiteUtilsFolderRelativePath();
if (path == null)
{
path = ImportExportHelper.GetSiteUtilsFolder();
}
lblError.Text = GetString("importconfiguration.securityerror").Replace("{0}", path + "Import");
}
if ((files != null) && (files.Count != 0))
{
lstImports.Enabled = true;
lstImports.DataSource = files;
lstImports.DataBind();
}
else
{
lstImports.Enabled = false;
}
}
if (!RequestHelper.IsPostBack())
{
try
{
lstImports.SelectedIndex = 0;
}
catch
{
}
}
}
/// <summary>
/// Imports user object. Called when the "Import object" button is pressed.
/// </summary>
private bool ImportObject()
{
// Create site import settings
SiteImportSettings settings = new SiteImportSettings(MembershipContext.AuthenticatedUser);
// Initialize the settings
settings.WebsitePath = Server.MapPath("~/");
settings.SourceFilePath = settings.WebsitePath + "CMSAPIExamples\\Code\\Tools\\ImportExport\\Packages\\APIExample_User.zip";
settings.ImportType = ImportTypeEnum.AllNonConflicting;
settings.LoadDefaultSelection();
// Import
ImportProvider.ImportObjectsData(settings);
// Delete temporary data
ImportProvider.DeleteTemporaryFiles(settings, false);
return(true);
}
/// <summary>
/// Imports site. Called when the "Import site" button is pressed.
/// </summary>
private bool ImportSite()
{
// Prepare the properties
string websitePath = Server.MapPath("~/");
string sourceFilePath = websitePath + "CMSAPIExamples\\Code\\Tools\\ImportExport\\Packages\\APIExample_Site.zip";
string siteDisplayName = "My new imported site";
string siteName = "MyNewImportedSite";
string siteDomain = "127.0.0.1";
// Ensure there is no site with the set name
if (SiteInfoProvider.GetSiteInfo(siteName) == null)
{
// Import
ImportProvider.ImportSite(siteName, siteDisplayName, siteDomain, sourceFilePath, websitePath, MembershipContext.AuthenticatedUser);
return(true);
}
return(false);
}
private void RefreshPackageList()
{
lstImports.Items.Clear();
List <string> files = null;
// Get import packages
try
{
files = ImportProvider.GetImportFilesList(targetFolder);
}
catch
{
// Show error and log exception
lblError.Text = GetString("importconfiguration.securityerror").Replace("{0}", ImportExportHelper.EXPORT_BACKUP_PATH);
}
if ((files != null) && (files.Count != 0))
{
lstImports.Enabled = true;
lstImports.DataSource = files;
lstImports.DataBind();
lstImports.SelectedIndex = 0;
}
else
{
lstImports.Enabled = false;
}
// Select first item
if (lstImports.Items.Count > 0)
{
lstImports.SelectedIndex = 0;
btnDelete.OnClientClick = "if (!confirm(" + ScriptHelper.GetLocalizedString("importconfiguration.deleteconf") + ")) { return false;}";
}
else
{
btnDelete.OnClientClick = "";
}
}
/// <summary>
/// Checks the license for selected objects.
/// </summary>
public static string CheckLicenses(SiteImportSettings settings)
{
string result = null;
object[,] checkFeatures = new object[, ] {
{ FeatureEnum.Unknown, "", false },
{ FeatureEnum.BizForms, FormObjectType.BIZFORM, true },
{ FeatureEnum.Forums, PredefinedObjectType.FORUM, true },
{ FeatureEnum.Newsletters, PredefinedObjectType.NEWSLETTER, true },
{ FeatureEnum.Subscribers, PredefinedObjectType.NEWSLETTERUSERSUBSCRIBER + ";" + PredefinedObjectType.NEWSLETTERROLESUBSCRIBER + ";" + PredefinedObjectType.NEWSLETTERSUBSCRIBER, true },
{ FeatureEnum.Staging, SynchronizationObjectType.STAGINGSERVER, true },
{ FeatureEnum.Ecommerce, PredefinedObjectType.SKU, false },
{ FeatureEnum.Polls, PredefinedObjectType.POLL, false },
{ FeatureEnum.Webfarm, WebFarmObjectType.WEBFARMSERVER, false },
{ FeatureEnum.SiteMembers, SiteObjectType.USER, false },
{ FeatureEnum.WorkflowVersioning, PredefinedObjectType.WORKFLOW, false }
};
// Get imported licenses
DataSet ds = ImportProvider.LoadObjects(settings, LicenseObjectType.LICENSEKEY, false);
string domain = string.IsNullOrEmpty(settings.SiteDomain) ? URLHelper.GetCurrentDomain().ToLower() : URLHelper.RemovePort(settings.SiteDomain).ToLower();
// Remove application path
int slashIndex = domain.IndexOf("/");
if (slashIndex > -1)
{
domain = domain.Substring(0, slashIndex);
}
bool anyDomain = ((domain == "localhost") || (domain == "127.0.0.1"));
// Check all features
for (int i = 0; i <= checkFeatures.GetUpperBound(0); i++)
{
string[] objectTypes = ((string)checkFeatures[i, 1]).Split(';');
bool siteObject = (bool)checkFeatures[i, 2];
string objectType = objectTypes[0];
// Check objects
int count = (objectType != "") ? 0 : 1;
for (int j = 0; j < objectTypes.Length; ++j)
{
objectType = objectTypes[j];
if (objectType != "")
{
ArrayList codenames = settings.GetSelectedObjects(objectType, siteObject);
count += (codenames == null) ? 0 : codenames.Count;
}
}
// Check a special case for Workflows
if (objectType.Equals(PredefinedObjectType.WORKFLOW))
{
// Check workflows
bool includeWorkflowScopes = ValidationHelper.GetBoolean(settings.GetSettings(ImportExportHelper.SETTINGS_WORKFLOW_SCOPES), false);
if (includeWorkflowScopes)
{
// Check if there are any workflow scopes in the imported package and if there are, increase the count.
DataSet dsScopes = ImportProvider.LoadObjects(settings, PredefinedObjectType.WORKFLOWSCOPE, true);
if (!DataHelper.DataSourceIsEmpty(dsScopes))
{
count++;
}
}
}
if (count > 0)
{
FeatureEnum feature = (FeatureEnum)checkFeatures[i, 0];
// Get best available license from DB
LicenseKeyInfo bestLicense = LicenseKeyInfoProvider.GetLicenseKeyInfo(domain, feature);
if ((bestLicense != null) && (bestLicense.ValidationResult != LicenseValidationEnum.Valid))
{
bestLicense = null;
}
// Check new licenses
LicenseKeyInfo bestSelected = null;
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow dr in ds.Tables[0].Rows)
{
LicenseKeyInfo lki = new LicenseKeyInfo(dr);
// Use license only if selected
if ((settings.IsSelected(LicenseObjectType.LICENSEKEY, lki.Domain, false)) && (anyDomain || (lki.Domain.ToLower() == domain)) && LicenseKeyInfoProvider.IsBetterLicense(lki, bestSelected, feature))
{
bestSelected = lki;
if (bestSelected.Domain.ToLower() == domain)
{
break;
}
}
}
}
// Check the license
if (feature == FeatureEnum.Unknown)
{
if ((bestLicense == null) && (bestSelected == null))
{
return(ResHelper.GetString("Import.NoLicense"));
}
}
else
{
// Check the limit
int limit = GetLimit(bestLicense, feature);
// Use a database license if it is better than the one which is being imported
if (LicenseKeyInfoProvider.IsBetterLicense(bestLicense, bestSelected, feature))
{
bestSelected = bestLicense;
}
int selectedLimit = GetLimit(bestSelected, feature);
if (bestSelected != null)
{
if (bestSelected.ValidationResult == LicenseValidationEnum.Valid)
{
if (!anyDomain || (bestSelected.Domain.ToLower() == domain))
{
limit = selectedLimit;
}
else
{
// If selected better, take the selected
if (selectedLimit > limit)
{
limit = selectedLimit;
}
}
}
else
{
if (!anyDomain || (bestSelected.Domain.ToLower() == domain))
{
limit = 0;
}
}
}
if (limit < count)
{
if (limit <= 0)
{
result += String.Format(ResHelper.GetString("Import.LimitZero"), ResHelper.GetString("ObjectTasks." + objectType.Replace(".", "_")));
}
else
{
result += String.Format(ResHelper.GetString("Import.LimitExceeded"), ResHelper.GetString("ObjectTasks." + objectType.Replace(".", "_")), limit);
}
// If better license
if ((bestLicense != null) && (bestSelected != null) && LicenseKeyInfoProvider.IsBetterLicense(bestLicense, bestSelected, feature))
{
result += " " + ResHelper.GetString("Import.BetterLicenseExists");
}
result += "<br />";
}
}
}
}
return(result);
}
protected void wzdImport_NextButtonClick(object sender, WizardNavigationEventArgs e)
{
switch (e.CurrentStepIndex)
{
// Import type
case 0:
{
if (!siteType.SelectTemplate)
{
try
{
// Get blank web template
WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo("BlankSite");
if (wi == null)
{
e.Cancel = true;
return;
}
WebTemplateID = wi.WebTemplateId;
string path = Server.MapPath(wi.WebTemplateFileName);
if (File.Exists(path + "\\template.zip"))
{
// Template from zip file
path += "\\" + ZipStorageProvider.GetZipFileName("template.zip");
ImportSettings.TemporaryFilesPath = path;
ImportSettings.SourceFilePath = path;
ImportSettings.TemporaryFilesCreated = true;
ImportSettings.RefreshMacroSecurity = true;
}
else
{
// Init the settings
ImportSettings.TemporaryFilesCreated = false;
ImportSettings.SourceFilePath = Server.MapPath(wi.WebTemplateFileName);
ImportSettings.RefreshMacroSecurity = true;
}
if (!File.Exists(ImportSettings.SourceFilePath))
{
try
{
ImportProvider.CreateTemporaryFiles(ImportSettings);
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
e.Cancel = true;
return;
}
}
if (SiteInfoProvider.GetSitesCount() == 0)
{
// No site exists, overwrite all
ImportSettings.ImportType = ImportTypeEnum.All;
ImportSettings.CopyFiles = false;
}
else
{
// Some site exists, only new objects
ImportSettings.ImportType = ImportTypeEnum.New;
}
ltlScriptAfter.Text = ScriptHelper.GetScript(
"var actDiv = document.getElementById('actDiv'); \n" +
"if (actDiv != null) { actDiv.style.display='block'; } \n" +
"var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } \n" +
"BTN_Disable('" + NextButton.ClientID + "'); \n" +
"StartSelectionTimer();"
);
// Preselect objects asynchronously
ctrlAsync.Parameter = "N";
ctrlAsync.RunAsync(SelectObjects, WindowsIdentity.GetCurrent());
e.Cancel = true;
}
catch (Exception ex)
{
lblError.Text = ex.Message;
e.Cancel = true;
return;
}
}
else
{
siteDetails.SiteName = null;
siteDetails.SiteDisplayName = null;
selectTemplate.ReloadData();
}
wzdImport.ActiveStepIndex++;
}
break;
// Template selection
case 1:
{
if (!selectTemplate.ApplySettings())
{
e.Cancel = true;
return;
}
// Init the settings
WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo(selectTemplate.WebTemplateId);
if (wi == null)
{
throw new Exception("Web template not found.");
}
ImportSettings.IsWebTemplate = true;
string path = Server.MapPath(wi.WebTemplateFileName);
if (File.Exists(path + "\\template.zip"))
{
// Template from zip file
path += "\\" + ZipStorageProvider.GetZipFileName("template.zip");
ImportSettings.TemporaryFilesPath = path;
ImportSettings.SourceFilePath = path;
ImportSettings.TemporaryFilesCreated = true;
ImportSettings.RefreshMacroSecurity = true;
}
else
{
// Template from folder
ImportSettings.TemporaryFilesCreated = false;
ImportSettings.SourceFilePath = path;
ImportSettings.RefreshMacroSecurity = true;
try
{
ImportProvider.CreateTemporaryFiles(ImportSettings);
}
catch (Exception ex)
{
lblError.Visible = true;
lblError.Text = ex.Message;
e.Cancel = true;
return;
}
}
if (SiteInfoProvider.GetSitesCount() == 0)
{
// No site exists, overwrite all
ImportSettings.ImportType = ImportTypeEnum.All;
}
else
{
// Some site exists, only new objects
ImportSettings.ImportType = ImportTypeEnum.New;
}
ltlScriptAfter.Text = ScriptHelper.GetScript(
"var actDiv = document.getElementById('actDiv');\n" +
"if (actDiv != null) { actDiv.style.display='block'; }\n" +
"var buttonsDiv = document.getElementById('buttonsDiv');\n" +
"if (buttonsDiv != null) { buttonsDiv.disabled=true; }\n" +
"BTN_Disable('" + NextButton.ClientID + "');\n" +
"BTN_Disable('" + PreviousButton.ClientID + "');\n" +
"StartSelectionTimer();"
);
// Preselect objects asynchronously
ctrlAsync.Parameter = "T";
ctrlAsync.RunAsync(SelectObjects, WindowsIdentity.GetCurrent());
e.Cancel = true;
}
break;
// Site details
case 2:
if (!siteDetails.ApplySettings())
{
e.Cancel = true;
return;
}
// Update settings
ImportSettings = siteDetails.Settings;
Culture = siteDetails.Culture;
pnlImport.ReloadData(true);
wzdImport.ActiveStepIndex++;
break;
// Objects selection
case 3:
if (!pnlImport.ApplySettings())
{
e.Cancel = true;
return;
}
// Check licences
string error = ImportExportControl.CheckLicenses(ImportSettings);
if (!string.IsNullOrEmpty(error))
{
lblError.Text = error;
e.Cancel = true;
return;
}
ImportSettings = pnlImport.Settings;
PreviousButton.Enabled = false;
NextButton.Enabled = false;
SiteName = ImportSettings.SiteName;
Domain = ImportSettings.SiteDomain;
// Init the Mimetype helper (required for the Import)
MimeTypeHelper.LoadMimeTypes();
// Start asynchronnous Import
ImportSettings.SetSettings(ImportExportHelper.SETTINGS_DELETE_TEMPORARY_FILES, false);
ImportSettings.DefaultProcessObjectType = ProcessObjectEnum.Selected;
ImportManager.Settings = ImportSettings;
// Import site asynchronously
ctrlImport.RunAsync(ImportManager.Import, WindowsIdentity.GetCurrent());
ctrlImport.PostbackOnError = false;
ltlScript.Text = ScriptHelper.GetScript("StartImportStateTimer();");
wzdImport.ActiveStepIndex++;
break;
// Import progress
case 4:
PreviousButton.Visible = false;
CultureHelper.SetPreferredCulture(Culture);
if (siteType.SelectTemplate)
{
// Done
finishSite.Domain = Domain;
finishSite.SiteIsRunning = SiteIsRunning;
wzdImport.ActiveStepIndex = 7;
}
else
{
if (ImportManager.Settings.IsWarning())
{
try
{
// Convert default culture
TreeProvider tree = new TreeProvider(CMSContext.CurrentUser);
tree.ChangeSiteDefaultCulture(SiteName, Culture, "en-US");
// Change root GUID
TreeNode root = DocumentHelper.GetDocument(SiteName, "/", Culture, false, "cms.root", null, null, 1, false, null, tree);
if (root != null)
{
root.NodeGUID = Guid.NewGuid();
DocumentHelper.UpdateDocument(root, tree);
}
}
catch (Exception ex)
{
EventLogProvider ev = new EventLogProvider();
ev.LogEvent("NewSiteWizard", "FINISH", ex);
lblError.Text = ex.Message;
e.Cancel = true;
return;
}
}
selectMaster.SiteName = SiteName;
selectMaster.ReloadData();
}
break;
// Master template
case 5:
if (!selectMaster.ApplySettings())
{
e.Cancel = true;
return;
}
siteStructure.SiteName = SiteName;
break;
// Define site structure
case 6:
finishSite.Domain = Domain;
finishSite.SiteIsRunning = SiteIsRunning;
break;
// Other steps
default:
wzdImport.ActiveStepIndex = e.NextStepIndex;
break;
}
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
if (!RequestHelper.IsCallback())
{
if (Settings != null)
{
if (SelectedNodeValue != DocumentObjectType.DOCUMENT)
{
DataSet ds = ImportProvider.LoadObjects(Settings, SelectedNodeValue, SiteNode, true);
// Bind grid view
gvObjects.Visible = true;
gvObjects.ObjectType = SelectedNodeValue;
gvObjects.Settings = Settings;
gvObjects.SiteObject = SiteNode;
gvObjects.DataSource = ds;
gvObjects.Bind();
gvTasks.Visible = true;
gvTasks.ObjectType = SelectedNodeValue;
gvTasks.Settings = Settings;
gvTasks.SiteObject = SiteNode;
gvTasks.DataSource = ds;
gvTasks.Bind();
}
else
{
gvObjects.Visible = false;
gvTasks.Visible = false;
}
// Reload settings control
if (settingsControl != null)
{
settingsControl.ReloadData();
}
}
if (SelectedNodeValue != "")
{
if (SelectedNodeValue.StartsWithCSafe("##"))
{
titleElem.TitleText = GetString("ImportTasks." + SelectedNodeValue.Replace(".", "_").Replace("#", "_"));
}
else
{
titleElem.TitleText = GetString("ObjectTasks." + SelectedNodeValue.Replace(".", "_").Replace("#", "_"));
}
titleElem.TitleImage = GetImageUrl("Objects/" + SelectedNodeValue.Replace(".", "_").Replace("#", "_") + "/object.png");
}
else
{
titleElem.TitleText = "";
}
pnlError.Visible = (lblError.Text != "");
// Save scrollbar position
mScrollPosition = ValidationHelper.GetString(Page.Request.Params["hdnDivScrollBar"], "0");
}
}
protected void Page_Load(object sender, EventArgs e)
{
// Register script for pendingCallbacks repair
ScriptHelper.FixPendingCallbacks(Page);
// Handle Import settings
if (!RequestHelper.IsCallback() && !RequestHelper.IsPostBack())
{
// Initialize import settings
ImportSettings = GetNewSettings();
}
if (wzdImport.ActiveStepIndex < 3)
{
stpConfigImport.Settings = ImportSettings;
stpSiteDetails.Settings = ImportSettings;
stpImport.Settings = ImportSettings;
}
if (!RequestHelper.IsCallback())
{
if (!VirtualPathHelper.UsingVirtualPathProvider)
{
SetWarningLabel(GetString("ImportSite.VirtualPathProviderNotRunning"));
}
ctrlAsyncUnzip.OnFinished += CtrlAsyncUnzipOnFinished;
ctrlAsyncUnzip.OnError += CtrlAsyncUnzipOnError;
ctlAsyncImport.OnCancel += ctlAsyncImport_OnCancel;
bool notTempPermissions = false;
if (wzdImport.ActiveStepIndex < 3)
{
// Ensure directory
try
{
DirectoryHelper.EnsureDiskPath(ImportSettings.TemporaryFilesPath + "\\temp.file", ImportSettings.WebsitePath);
}
catch (IOExceptions.IOException ex)
{
pnlWrapper.Visible = false;
SetAlertLabel(lblErrorBlank, ex.Message);
return;
}
// Check permissions
notTempPermissions = !DirectoryHelper.CheckPermissions(ImportSettings.TemporaryFilesPath, true, true, false, false);
}
if (notTempPermissions)
{
pnlWrapper.Visible = false;
pnlPermissions.Visible = true;
SetAlertLabel(lblErrorBlank, String.Format(GetString("ImportSite.ErrorPermissions"), ImportSettings.TemporaryFilesPath, WindowsIdentity.GetCurrent().Name));
lnkPermissions.Target = "_blank";
lnkPermissions.Text = GetString("Install.ErrorPermissions");
lnkPermissions.NavigateUrl = DocumentationHelper.GetDocumentationTopicUrl(HELP_TOPIC_DISKPERMISSIONS_LINK);
}
else
{
if (!RequestHelper.IsPostBack())
{
// Delete temporary files
try
{
// Delete only folder structure if there is not special folder
bool onlyFolderStructure = !Directory.Exists(DirectoryHelper.CombinePath(ImportSettings.TemporaryFilesPath, ImportExportHelper.FILES_FOLDER));
ImportProvider.DeleteTemporaryFiles(ImportSettings, onlyFolderStructure);
}
catch (Exception ex)
{
pnlWrapper.Visible = false;
SetAlertLabel(lblErrorBlank, GetString("ImportSite.ErrorDeletionTemporaryFiles") + " " + ex.Message);
return;
}
}
// Javascript functions
string script = String.Format(
@"
function Finished(sender) {{
var errorElement = document.getElementById('{2}');
var errorText = sender.getErrors();
if (errorText != '') {{
errorElement.innerHTML = errorText;
document.getElementById('{4}').style.removeProperty('display');
}}
var warningElement = document.getElementById('{3}');
var warningText = sender.getWarnings();
if (warningText != '') {{
warningElement.innerHTML = warningText;
document.getElementById('{5}').style.removeProperty('display');
}}
var actDiv = document.getElementById('actDiv');
if (actDiv != null) {{
actDiv.style.display = 'none';
}}
BTN_Disable('{0}');
BTN_Enable('{1}');
if ((errorText == null) || (errorText == '')) {{
BTN_Enable('{6}');
}}
}}
",
CancelButton.ClientID,
FinishButton.ClientID,
lblError.LabelClientID,
lblWarning.LabelClientID,
pnlError.ClientID,
pnlWarning.ClientID,
NextButton.ClientID
);
// Register the script to perform get flags for showing buttons retrieval callback
ScriptHelper.RegisterClientScriptBlock(this, GetType(), "Finished", ScriptHelper.GetScript(script));
// Add cancel button attribute
CancelButton.Attributes.Add("onclick", ctlAsyncImport.GetCancelScript(true) + "return false;");
wzdImport.NextButtonClick += wzdImport_NextButtonClick;
wzdImport.PreviousButtonClick += wzdImport_PreviousButtonClick;
wzdImport.FinishButtonClick += wzdImport_FinishButtonClick;
if (!RequestHelper.IsPostBack())
{
stpConfigImport.InitControl();
}
}
}
}
private static void Upgrade60Import()
{
EventLogProvider evp = new EventLogProvider();
// Import
try
{
RequestStockHelper.Remove("CurrentDomain", true);
SiteImportSettings importSettings = new SiteImportSettings(CMSContext.CurrentUser)
{
DefaultProcessObjectType = ProcessObjectEnum.All,
SourceFilePath = mUpgradePackagePath,
WebsitePath = mWebsitePath
};
ImportProvider.ImportObjectsData(importSettings);
// Regenerate time zones
TimeZoneInfoProvider.GenerateTimeZoneRules();
#region "Separability"
String webPartsPath = mWebsitePath + "CMSWebParts\\";
List <String> files = new List <string>();
// Create list of files to remove
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.BIZFORM))
{
files.AddRange(GetAllFiles(webPartsPath + "BizForms"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.BLOGS))
{
files.AddRange(GetAllFiles(webPartsPath + "Blogs"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.COMMUNITY))
{
files.AddRange(GetAllFiles(webPartsPath + "Community"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.ECOMMERCE))
{
files.AddRange(GetAllFiles(webPartsPath + "Ecommerce"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.EVENTMANAGER))
{
files.AddRange(GetAllFiles(webPartsPath + "Events"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.FORUMS))
{
files.AddRange(GetAllFiles(webPartsPath + "Forums"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.MEDIALIBRARY))
{
files.AddRange(GetAllFiles(webPartsPath + "MediaLibrary"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.MESSAGEBOARD))
{
files.AddRange(GetAllFiles(webPartsPath + "MessageBoards"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.MESSAGING))
{
files.AddRange(GetAllFiles(webPartsPath + "Messaging"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.NEWSLETTER))
{
files.AddRange(GetAllFiles(webPartsPath + "Newsletters"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.NOTIFICATIONS))
{
files.AddRange(GetAllFiles(webPartsPath + "Notifications"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.ONLINEMARKETING))
{
files.AddRange(GetAllFiles(webPartsPath + "OnlineMarketing"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.POLLS))
{
files.AddRange(GetAllFiles(webPartsPath + "Polls"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.PROJECTMANAGEMENT))
{
files.AddRange(GetAllFiles(webPartsPath + "ProjectManagement"));
}
if (!ModuleEntry.IsModuleLoaded(ModuleEntry.REPORTING))
{
files.AddRange(GetAllFiles(webPartsPath + "Reporting"));
}
// Remove webparts for separated modules
foreach (String file in files)
{
try
{
File.Delete(file);
}
catch (Exception ex)
{
evp.LogEvent("Upgrade to 6.0", "Upgrade", ex);
}
}
#endregion
evp.LogEvent("I", DateTime.Now, "Upgrade to 6.0", "Upgrade - Finish");
}
catch (Exception ex)
{
evp.LogEvent("Upgrade to 6.0", "Upgrade", ex);
}
}
protected void wzdImport_NextButtonClick(object sender, WizardNavigationEventArgs e)
{
var settings = ImportSettings;
ClearErrorLabel();
switch (e.CurrentStepIndex)
{
// Import type
case 0:
{
if (!siteType.SelectTemplate)
{
try
{
// Get blank web template
WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo("BlankSite");
if (wi == null)
{
e.Cancel = true;
return;
}
WebTemplateID = wi.WebTemplateId;
string path = Server.MapPath(wi.WebTemplateFileName);
if (File.Exists(path + "\\template.zip"))
{
// Template from zip file
path += "\\" + ZipStorageProvider.GetZipFileName("template.zip");
settings.TemporaryFilesPath = path;
settings.SourceFilePath = path;
settings.TemporaryFilesCreated = true;
settings.RefreshMacroSecurity = true;
}
else
{
// Init the settings
settings.TemporaryFilesCreated = false;
settings.SourceFilePath = Server.MapPath(wi.WebTemplateFileName);
settings.RefreshMacroSecurity = true;
}
if (!File.Exists(settings.SourceFilePath))
{
try
{
ImportProvider.CreateTemporaryFiles(settings);
}
catch (Exception ex)
{
SetErrorLabel(ex.Message);
e.Cancel = true;
return;
}
}
// Import all, but only add new data
settings.ImportType = ImportTypeEnum.AllNonConflicting;
settings.ImportOnlyNewObjects = true;
settings.CopyFiles = false;
// Allow bulk inserts for faster import, web templates must be consistent enough to allow this without collisions
settings.AllowBulkInsert = true;
ltlScriptAfter.Text = ScriptHelper.GetScript(
"var actDiv = document.getElementById('actDiv'); \n" +
"if (actDiv != null) { actDiv.style.display='block'; } \n" +
"var buttonsDiv = document.getElementById('buttonsDiv'); if (buttonsDiv != null) { buttonsDiv.disabled=true; } \n" +
"BTN_Disable('" + NextButton.ClientID + "'); \n" +
"StartSelectionTimer();"
);
// Preselect objects asynchronously
ctrlAsyncSelection.Parameter = "N";
ctrlAsyncSelection.RunAsync(SelectObjects, WindowsIdentity.GetCurrent());
e.Cancel = true;
}
catch (Exception ex)
{
SetErrorLabel(ex.Message);
e.Cancel = true;
return;
}
}
else
{
siteDetails.SiteName = null;
siteDetails.SiteDisplayName = null;
selectTemplate.ReloadData();
}
wzdImport.ActiveStepIndex++;
}
break;
// Template selection
case 1:
{
if (!selectTemplate.ApplySettings())
{
e.Cancel = true;
return;
}
// Init the settings
WebTemplateInfo wi = WebTemplateInfoProvider.GetWebTemplateInfo(selectTemplate.WebTemplateId);
if (wi == null)
{
throw new Exception("Web template not found.");
}
settings.IsWebTemplate = true;
string path = Server.MapPath(wi.WebTemplateFileName);
if (File.Exists(path + "\\template.zip"))
{
// Template from zip file
path += "\\" + ZipStorageProvider.GetZipFileName("template.zip");
settings.TemporaryFilesPath = path;
settings.SourceFilePath = path;
settings.TemporaryFilesCreated = true;
settings.RefreshMacroSecurity = true;
}
else
{
// Template from folder
settings.TemporaryFilesCreated = false;
settings.SourceFilePath = path;
settings.RefreshMacroSecurity = true;
try
{
ImportProvider.CreateTemporaryFiles(settings);
}
catch (Exception ex)
{
SetErrorLabel(ex.Message);
e.Cancel = true;
return;
}
}
// Import all, but only add new data
settings.ImportType = ImportTypeEnum.AllNonConflicting;
settings.ImportOnlyNewObjects = true;
settings.CopyFiles = false;
// Allow bulk inserts for faster import, web templates must be consistent enough to allow this without collisions
settings.AllowBulkInsert = true;
ltlScriptAfter.Text = ScriptHelper.GetScript(
"var actDiv = document.getElementById('actDiv');\n" +
"if (actDiv != null) { actDiv.style.display='block'; }\n" +
"var buttonsDiv = document.getElementById('buttonsDiv');\n" +
"if (buttonsDiv != null) { buttonsDiv.disabled=true; }\n" +
"BTN_Disable('" + NextButton.ClientID + "');\n" +
"BTN_Disable('" + PreviousButton.ClientID + "');\n" +
"StartSelectionTimer();"
);
// Preselect objects asynchronously
ctrlAsyncSelection.Parameter = "T";
ctrlAsyncSelection.RunAsync(SelectObjects, WindowsIdentity.GetCurrent());
e.Cancel = true;
}
break;
// Site details
case 2:
if (!siteDetails.ApplySettings())
{
e.Cancel = true;
return;
}
// Update settings
ImportSettings = siteDetails.Settings;
if (!siteType.SelectTemplate && (ImportSettings.SiteName == InfoHelper.CODENAME_AUTOMATIC))
{
ImportSettings.SiteName = ValidationHelper.GetCodeName(settings.SiteDisplayName);
}
Culture = siteDetails.Culture;
pnlImport.ReloadData(true);
wzdImport.ActiveStepIndex++;
break;
// Objects selection
case 3:
if (!pnlImport.ApplySettings())
{
e.Cancel = true;
return;
}
// Check licenses
string error = ImportExportControl.CheckLicenses(settings);
if (!string.IsNullOrEmpty(error))
{
SetErrorLabel(error);
e.Cancel = true;
return;
}
ImportSettings = pnlImport.Settings;
PreviousButton.Enabled = false;
NextButton.Enabled = false;
SiteName = settings.SiteName;
Domain = settings.SiteDomain;
// Start asynchronous Import
settings.SetSettings(ImportExportHelper.SETTINGS_DELETE_TEMPORARY_FILES, false);
settings.DefaultProcessObjectType = ProcessObjectEnum.Selected;
var manager = ImportManager;
settings.LogContext = ctlAsyncImport.CurrentLog;
manager.Settings = settings;
// Import site asynchronously
ctlAsyncImport.RunAsync(ImportManager.Import, WindowsIdentity.GetCurrent());
wzdImport.ActiveStepIndex++;
break;
// Import progress
case 4:
PreviousButton.Visible = false;
CultureHelper.SetPreferredCulture(Culture);
if (siteType.SelectTemplate)
{
// Done
finishSite.Domain = Domain;
finishSite.SiteIsRunning = SiteIsRunning;
wzdImport.ActiveStepIndex = 6;
}
else
{
if (ImportManager.Settings.IsWarning())
{
try
{
// Convert default culture
TreeProvider tree = new TreeProvider(MembershipContext.AuthenticatedUser);
tree.ChangeSiteDefaultCulture(SiteName, Culture, "en-US");
// Change root GUID
TreeNode root = DocumentHelper.GetDocument(SiteName, "/", Culture, false, SystemDocumentTypes.Root, null, null, 1, false, null, tree);
if (root != null)
{
root.NodeGUID = Guid.NewGuid();
DocumentHelper.UpdateDocument(root, tree);
}
}
catch (Exception ex)
{
EventLogProvider.LogException("NewSiteWizard", "FINISH", ex);
SetErrorLabel(ex.Message);
e.Cancel = true;
NextButton.Enabled = false;
CancelButton.Enabled = false;
mImportCanceled = true;
return;
}
}
selectMaster.SiteName = SiteName;
selectMaster.ReloadData();
}
break;
case 5:
if (!selectMaster.ApplySettings())
{
e.Cancel = true;
return;
}
finishSite.Domain = Domain;
finishSite.SiteIsRunning = SiteIsRunning;
break;
// Other steps
default:
wzdImport.ActiveStepIndex = e.NextStepIndex;
break;
}
}
// Create temporary files and preselect objects
private void CreateTemporaryFiles(object parameter)
{
ImportProvider.CreateTemporaryFiles(ImportSettings);
ImportSettings.LoadDefaultSelection();
}
protected void Page_Load(object sender, EventArgs e)
{
// Register script for pendingCallbacks repair
ScriptHelper.FixPendingCallbacks(Page);
// Handle Import settings
if (!Page.IsCallback && !RequestHelper.IsPostBack())
{
// Initialize virtual path provider
VirtualPathHelper.Init(Page);
// Initialize import settings
ImportSettings = GetNewSettings();
}
if (!Page.IsCallback)
{
if (!SettingsKeyProvider.UsingVirtualPathProvider)
{
lblWarning.Visible = true;
lblWarning.Text = GetString("ImportSite.VirtualPathProviderNotRunning");
}
ctrlAsync.OnFinished += ctrlAsync_OnFinished;
ctrlAsync.OnError += ctrlAsync_OnError;
bool notTempPermissions = false;
if (wzdImport.ActiveStepIndex < 3)
{
stpConfigImport.Settings = ImportSettings;
stpSiteDetails.Settings = ImportSettings;
stpImport.Settings = ImportSettings;
// Ensure directory
DirectoryHelper.EnsureDiskPath(ImportSettings.TemporaryFilesPath + "\\temp.file", ImportSettings.WebsitePath);
// Check permissions
notTempPermissions = !DirectoryHelper.CheckPermissions(ImportSettings.TemporaryFilesPath, true, true, false, false);
}
if (notTempPermissions)
{
pnlWrapper.Visible = false;
lblError.Text = string.Format(GetString("ImportSite.ErrorPermissions"), ImportSettings.TemporaryFilesPath, WindowsIdentity.GetCurrent().Name);
pnlPermissions.Visible = true;
lnkPermissions.Target = "_blank";
lnkPermissions.Text = GetString("Install.ErrorPermissions");
lnkPermissions.NavigateUrl = ResolveUrl("~/CMSMessages/ConfigurePermissions.aspx");
}
else
{
if (!RequestHelper.IsPostBack())
{
// Delete temporary files
try
{
// Delete only folder structure if there is not special folder
bool onlyFolderStructure = !Directory.Exists(DirectoryHelper.CombinePath(ImportSettings.TemporaryFilesPath, ImportExportHelper.FILES_FOLDER));
ImportProvider.DeleteTemporaryFiles(ImportSettings, onlyFolderStructure);
}
catch (Exception ex)
{
pnlWrapper.Visible = false;
lblError.Text = GetString("ImportSite.ErrorDeletionTemporaryFiles") + ex.Message;
return;
}
}
// Javascript functions
string script =
"var imMessageText = '';\n" +
"var imErrorText = '';\n" +
"var imWarningText = '';\n" +
"var imMachineName = '" + SqlHelperClass.MachineName.ToLowerCSafe() + "';\n" +
"var getBusy = false;\n" +
"function GetImportState(cancel)\n" +
"{ if(window.Activity){window.Activity();} if (getBusy && !cancel) return; getBusy = true; setTimeout(\"getBusy = false;\", 2000); var argument = cancel + ';' + imMessageText.length + ';' + imErrorText.length + ';' + imWarningText.length + ';' + imMachineName; return " + Page.ClientScript.GetCallbackEventReference(this, "argument", "SetImportStateMssg", "argument", true) + " }\n";
script +=
"function SetImportStateMssg(rValue, context)\n" +
"{\n" +
" getBusy = false;\n" +
" if(rValue != '')\n" +
" {\n" +
" var args = context.split(';');\n" +
" var values = rValue.split('" + SiteExportSettings.SEPARATOR + "');\n" +
" var messageElement = document.getElementById('" + lblProgress.ClientID + "');\n" +
" var errorElement = document.getElementById('" + lblError.ClientID + "');\n" +
" var warningElement = document.getElementById('" + lblWarning.ClientID + "');\n" +
" var messageText = imMessageText;\n" +
" messageText = values[1] + messageText.substring(messageText.length - args[1]);\n" +
" if(messageText.length > imMessageText.length){ imMessageText = messageElement.innerHTML = messageText; }\n" +
" var errorText = imErrorText;\n" +
" errorText = values[2] + errorText.substring(errorText.length - args[2]);\n" +
" if(errorText.length > imErrorText.length){ imErrorText = errorElement.innerHTML = errorText; }\n" +
" var warningText = imWarningText;\n" +
" warningText = values[3] + warningText.substring(warningText.length - args[3]);\n" +
" if(warningText.length > imWarningText.length){ imWarningText = warningElement.innerHTML = warningText; }\n" +
" if((values=='') || (values[0]=='F'))\n" +
" {\n" +
" StopImportStateTimer();\n" +
" BTN_Disable('" + CancelButton.ClientID + "');\n" +
" BTN_Enable('" + FinishButton.ClientID + "');\n" +
" }\n" +
" }\n" +
"}\n";
// Register the script to perform get flags for showing buttons retrieval callback
ScriptHelper.RegisterClientScriptBlock(this, GetType(), "GetSetImportState", ScriptHelper.GetScript(script));
// Add cancel button attribute
CancelButton.Attributes.Add("onclick", "BTN_Disable('" + CancelButton.ClientID + "');" + "return CancelImport();");
wzdImport.NextButtonClick += wzdImport_NextButtonClick;
wzdImport.PreviousButtonClick += wzdImport_PreviousButtonClick;
wzdImport.FinishButtonClick += wzdImport_FinishButtonClick;
if (!RequestHelper.IsPostBack())
{
stpConfigImport.InitControl();
}
}
}
}
/// <summary>
/// Apply control settings.
/// </summary>
public bool ApplySettings()
{
// Set additional settings
Settings.ExistingSite = !radNewSite.Checked;
Settings.SetSettings(ImportExportHelper.SETTINGS_BIZFORM_DATA, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_FORUM_POSTS, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_BOARD_MESSAGES, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_USER_DASHBOARDS, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_USER_SITE_DASHBOARDS, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_PAGETEMPLATE_SCOPES, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_PAGETEMPLATE_VARIANTS, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_CUSTOMTABLE_DATA, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_WORKFLOW_SCOPES, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_WORKFLOW_TRIGGERS, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_MEDIA_FILES, radNewSite.Checked);
Settings.SetSettings(ImportExportHelper.SETTINGS_MEDIA_FILES_PHYSICAL, radNewSite.Checked);
if (!radNewSite.Checked)
{
Settings.SiteId = ValidationHelper.GetInteger(siteSelector.Value, 0);
// Get site info
SiteInfo si = SiteInfoProvider.GetSiteInfo(Settings.SiteId);
if (si != null)
{
Settings.SiteDisplayName = si.DisplayName;
Settings.SiteDomain = si.DomainName;
Settings.SiteName = si.SiteName;
Settings.SiteDescription = si.Description;
Settings.SiteIsContentOnly = si.SiteIsContentOnly;
Settings.SitePresentationUrl = si.SitePresentationURL;
var packageSiteTable = ImportProvider.GetObjectsData(Settings, SiteInfo.OBJECT_TYPE, true);
if (!DataHelper.DataSourceIsEmpty(packageSiteTable))
{
var packageSite = new SiteInfo(packageSiteTable.Rows[0]);
// Do not import site if target site is incompatible with the site in package
if (packageSite.SiteIsContentOnly != Settings.SiteIsContentOnly)
{
Settings.SetSettings(ImportExportHelper.SETTINGS_UPDATE_SITE_DEFINITION, false);
}
}
}
return(true);
}
Settings.SiteId = 0;
// Existing site
bool isValid = rfvSiteDisplayName.IsValid && rfvDomain.IsValid;
// Get site name
var siteName = txtSiteName.Text.Trim();
if (siteName != InfoHelper.CODENAME_AUTOMATIC)
{
var validator = new Validator().NotEmpty(siteName, GetString("ImportSite.StepSiteDetails.SiteNameError"))
.IsCodeName(siteName, GetString("ImportSite.StepSiteDetails.SiteNameNotValid"));
// Get validation result
string codeNameError = validator.Result;
// Check if there is site with specified code name
if (string.IsNullOrEmpty(codeNameError) && SiteInfoProvider.GetSiteInfo(siteName) != null)
{
codeNameError = GetString("NewSite_SiteDetails.ErrorSiteExists");
}
if (!string.IsNullOrEmpty(codeNameError))
{
lblErrorSiteName.Text = codeNameError;
lblErrorSiteName.Visible = true;
isValid = false;
}
}
if (isValid)
{
txtDomain.Text = URLHelper.RemoveProtocol(txtDomain.Text);
// Set site details
Settings.SiteDisplayName = txtSiteDisplayName.Text;
Settings.SiteDomain = txtDomain.Text;
Settings.SiteName = siteName;
}
return(isValid);
}
