protected void Page_Load(object sender, EventArgs e)
{
if (!StopProcessing)
{
// Initialize button for adding packages
newImportPackage.DisplayInline = true;
newImportPackage.AllowedExtensions = "zip";
newImportPackage.ParentElemID = ClientID;
newImportPackage.ForceLoad = true;
newImportPackage.ShowProgress = false;
newImportPackage.CheckPermissions = true;
newImportPackage.SourceType = MediaSourceEnum.PhysicalFile;
newImportPackage.TargetFolderPath = ImportExportHelper.GetSiteUtilsFolder() + "Import";
newImportPackage.Text = GetString("importconfiguration.uploadpackage");
newImportPackage.InnerElementClass = "NewAttachment";
newImportPackage.InnerLoadingElementClass = "NewAttachmentLoading";
newImportPackage.DisplayInline = true;
newImportPackage.AfterSaveJavascript = "Refresh" + ClientID;
ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "Refresh" + ClientID, ScriptHelper.GetScript("function Refresh" + ClientID + "(){" + Page.ClientScript.GetPostBackEventReference(btnRefresh, null).Replace("'", "\"") + "}"));
if (!RequestHelper.IsCallback() && !RequestHelper.IsPostBack())
{
radAll.Text = GetString("ImportConfiguration.All");
radNew.Text = GetString("ImportConfiguration.Date");
// Load imports list
RefreshPackageList(null);
}
}
}
/// <summary>
/// Exports site. Called when the "Export site" button is pressed.
/// Expects the ImportSite method to be run first.
/// </summary>
private bool ExportSite()
{
// Delete temporary data
try
{
ExportProvider.DeleteTemporaryFiles();
}
catch
{
}
// Prepare the properties
string websitePath = Server.MapPath("~/");
string exportFileName = string.Format("APIExample_Site_{0:yyyy-MM-dd_hh-mm}.zip", DateTime.Now);
string exportFilePath = FileHelper.GetFullFolderPhysicalPath(ImportExportHelper.GetSiteUtilsFolder(), websitePath) + "Export\\" + exportFileName;
string siteName = "MyNewImportedSite";
// Ensure that site exists
if (SiteInfoProvider.GetSiteInfo(siteName) != null)
{
// Ensure there is no exported package with the same name
if (!File.Exists(exportFilePath))
{
// Export
ExportProvider.ExportSite(siteName, exportFilePath, websitePath, false, MembershipContext.AuthenticatedUser);
return(true);
}
}
return(false);
}
/// <summary>
/// Deletes exported packages. Called when the "Delete exported packages" button is pressed.
/// </summary>
private bool DeletePackages()
{
// Prepare parameters
string websitePath = Server.MapPath("~/");
string exportPath = FileHelper.GetFullFolderPhysicalPath(ImportExportHelper.GetSiteUtilsFolder(), websitePath) + "Export\\";
string filesToDelete = @"APIExample*.zip";
// Get list of export packages
string[] fileList = Directory.GetFiles(exportPath, filesToDelete);
bool filesDeleted = true;
// Delete each file
foreach (string file in fileList)
{
try
{
File.Delete(file);
}
catch
{
// Deletion was unsuccessfull
filesDeleted = false;
}
}
return(filesDeleted);
}
/// <summary>
/// Exports user object. Called when the "Export object" button is pressed.
/// Expects the ImportUser method to be run first.
/// </summary>
private bool ExportObject()
{
// Delete temporary data
try
{
ExportProvider.DeleteTemporaryFiles();
}
catch
{
}
// Get user
UserInfo exportedUser = UserInfoProvider.GetUserInfo("MyNewImportedUser");
// Ensure that user exists
if (exportedUser != null)
{
// Prepare the properties
string websitePath = Server.MapPath("~/");
string exportFileName = string.Format("APIExample_User_{0:yyyy-MM-dd_hh-mm}.zip", DateTime.Now);
string exportFilePath = FileHelper.GetFullFilePhysicalPath(ImportExportHelper.GetSiteUtilsFolder(), websitePath) + "Export\\" + exportFileName;
// Ensure there is no exported package with the same name
if (!File.Exists(exportFilePath))
{
// Export
ExportProvider.ExportObject(exportedUser, exportFilePath, websitePath, CMSContext.CurrentUser);
return(true);
}
}
return(false);
}
/// <summary>
/// Creates new settings object for export.
/// </summary>
private SiteExportSettings GetNewSettings()
{
SiteExportSettings result = new SiteExportSettings(MembershipContext.AuthenticatedUser);
result.WebsitePath = Server.MapPath("~/");
result.TargetPath = ImportExportHelper.GetSiteUtilsFolder() + "Export";
result.PersistentSettingsKey = PersistentSettingsKey;
return(result);
}
/// <summary>
/// Testing '~/CMSSiteUtils/TestFiles/TestModify.txt' modification.
/// </summary>
protected void ModifyTest(string path)
{
string filePath = path + "TestModify.txt";
string strOK = GetString("General.OK");
string strFailed = GetString("System_Files.Failed");
string strSkipped = GetString("System_Files.ExternalStorage.ModifySkipped");
string targetPath = ImportExportHelper.GetSiteUtilsFolderRelativePath();
ltlInfo.Text += "<br /><br />";
// Skip test on external storage
if (StorageHelper.IsExternalStorage(filePath))
{
ltlInfo.Text += strSkipped;
return;
}
// Path is full path
if (targetPath == null)
{
targetPath = ImportExportHelper.GetSiteUtilsFolder() + "TestFiles\\";
}
else
{
targetPath = targetPath + "TestFiles/";
}
ltlInfo.Text += GetString("System_Files.Modifying") + " '" + targetPath + "TestModify.txt' - ";
FileInfo fi = FileInfo.New(filePath);
// If the file exists, try to append some text
if (fi.Exists)
{
try
{
using (StreamWriter sw = fi.CreateText())
{
sw.WriteLine(ltlInfo.Text.Replace("<br />", "\n") + strOK);
}
ltlInfo.Text += strOK;
}
catch
{
ltlInfo.Text += strFailed;
}
}
else
{
ltlInfo.Text += strFailed;
}
}
// 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
{
}
}
}
private string GetTargetFolder()
{
string targetFolder = null;
if (IsBackupMode)
{
string path = ImportExportHelper.GetObjectBackupFolder(ExportedObjectInfo);
targetFolder = Server.MapPath(path);
}
else
{
targetFolder = ImportExportHelper.GetSiteUtilsFolder() + "Export";
}
return(targetFolder);
}
/// <summary>
/// On btnTest click.
/// </summary>
protected void btnTest_Click(object sender, EventArgs e)
{
// Path to 'TestFiles' directory
string path = ImportExportHelper.GetSiteUtilsFolder() + "TestFiles\\";
DirectoryInfo di = DirectoryInfo.New(path);
if (di.Exists)
{
CreateDeleteTest(path, di);
// Modify file
ModifyTest(path);
}
else
{
ShowError("Directory " + path + " wasn't found!");
}
}
/// <summary>
/// Refresh button click handler.
/// </summary>
protected void btnDelete_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(lstImports.SelectedValue))
{
try
{
File.Delete(ImportExportHelper.GetSiteUtilsFolder() + "Import\\" + lstImports.SelectedValue);
}
catch (Exception ex)
{
ScriptHelper.RegisterStartupScript(Page, typeof(string), "ErrorMessage", ScriptHelper.GetAlertScript(ex.Message));
}
finally
{
RefreshPackageList(sender);
}
}
}
/// <summary>
/// Loads files to import.
/// </summary>
private void LoadFiles()
{
if (this.lstImports.Items.Count == 0)
{
// Get files with licenses
ArrayList files = new ArrayList();
string path = ImportExportHelper.GetSiteUtilsFolder() + "Import";
// if import path exists
if (Directory.Exists(path))
{
// Get files in directory
string[] filesInDir = Directory.GetFiles(path, "*.txt");
for (int i = 0; i < filesInDir.Length; i++)
{
files.Add(filesInDir[i].Substring(filesInDir[i].LastIndexOf("\\") + 1));
}
}
if (files.Count != 0)
{
lstImports.Enabled = true;
lstImports.DataSource = files;
lstImports.DataBind();
}
else
{
lstImports.Enabled = false;
}
}
if (!RequestHelper.IsPostBack())
{
try
{
lstImports.SelectedIndex = 0;
}
catch
{
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!StopProcessing)
{
imgRefresh.ImageUrl = GetImageUrl("CMSModules/CMS_EmailQueue/refresh.png");
imgDelete.ImageUrl = GetImageUrl("Design/Controls/EditModeButtons/delete.png");
// Initialize button for adding packages
newImportPackage.ImageUrl = ResolveUrl(GetImageUrl("Design/Controls/DirectUploader/uploadpackage.png"));
newImportPackage.DisplayInline = true;
newImportPackage.ImageWidth = 16;
newImportPackage.ImageHeight = 16;
newImportPackage.AllowedExtensions = "zip";
newImportPackage.ParentElemID = ClientID;
newImportPackage.ForceLoad = true;
newImportPackage.ShowProgress = false;
newImportPackage.CheckPermissions = true;
newImportPackage.SourceType = MediaSourceEnum.PhysicalFile;
newImportPackage.TargetFolderPath = ImportExportHelper.GetSiteUtilsFolder() + "Import";
newImportPackage.InnerDivHtml = GetString("importconfiguration.uploadpackage");
newImportPackage.InnerDivClass = "NewAttachment";
newImportPackage.InnerLoadingDivHtml = GetString("importconfiguration.uploading");
newImportPackage.InnerLoadingDivClass = "NewAttachmentLoading";
newImportPackage.DisplayInline = true;
newImportPackage.AfterSaveJavascript = "Refresh" + ClientID;
ScriptHelper.RegisterClientScriptBlock(this, typeof(string), "Refresh" + ClientID, ScriptHelper.GetScript("function Refresh" + ClientID + "(){" + Page.ClientScript.GetPostBackEventReference(btnRefresh, null).Replace("'", "\"") + "}"));
lblImports.Text = GetString("ImportConfiguration.Imports");
if (!Page.IsCallback && !RequestHelper.IsPostBack())
{
radAll.Text = GetString("ImportConfiguration.All");
radNew.Text = GetString("ImportConfiguration.Date");
// Load imports list
RefreshPackageList(null);
}
}
}
/// <summary>
/// Apply control settings.
/// </summary>
public bool ApplySettings()
{
string result = null;
// File is not selected, inform the user
if (lstImports.SelectedItem == null)
{
result = GetString("ImportConfiguration.FileError");
}
if (string.IsNullOrEmpty(result))
{
try
{
// Set current user information
Settings.CurrentUser = MembershipContext.AuthenticatedUser;
// Set source filename
Settings.SourceFilePath = ImportExportHelper.GetSiteUtilsFolder() + "Import\\" + lstImports.SelectedValue;
// Unpack the files
Settings.TemporaryFilesCreated = false;
// Init default values
Settings.ImportType = radAll.Checked ? ImportTypeEnum.AllNonConflicting : ImportTypeEnum.New;
}
catch (Exception ex)
{
lblError.Text = ex.Message;
return(false);
}
}
else
{
lblError.Text = result;
return(false);
}
return(true);
}
/// <summary>
/// Gets the path to the location of the package based on provided package <see cref="metadata"/>.
/// </summary>
/// <param name="metadata">Metadata of the package</param>
private string GetPackageFilePath(ModulePackageMetadata metadata)
{
return(Path.EnsureBackslashes(Path.Combine(Path.Combine(ImportExportHelper.GetSiteUtilsFolder(), "Export"), String.Format("{0}_{1}.nupkg", metadata.Id, metadata.Version))));
}
/// <summary>
/// Button Ok click.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="e">Arguments</param>
protected void btnOk_Click(object sender, EventArgs e)
{
// Validate file name
string fileName = txtFileName.Text.Trim();
string errorMessage = new Validator().NotEmpty(fileName, GetString("lincense.export.filenameempty")).IsFileName(fileName, GetString("license.export.notvalidfilename")).Result;
if (!string.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
else
{
try
{
// Create writers
string path = ImportExportHelper.GetSiteUtilsFolder() + "Export\\" + fileName;
DirectoryHelper.EnsureDiskPath(path, SettingsKeyProvider.WebApplicationPhysicalPath);
using (FileStream file = FileStream.New(path, FileMode.Create))
{
using (StreamWriter sw = StreamWriter.New(file))
{
// Array list for duplicity checking
ArrayList allSites = new ArrayList();
// Get all sites
DataSet sites = SiteInfoProvider.GetSites(null, null, "SiteID,SiteDomainName");
if (!DataHelper.DataSourceIsEmpty(sites))
{
foreach (DataRow dr in sites.Tables[0].Rows)
{
// Get domain
string domain = ValidationHelper.GetString(dr["SiteDomainName"], "");
if (!string.IsNullOrEmpty(domain))
{
domain = GetDomain(domain);
// Add to file
if (!allSites.Contains(domain))
{
sw.WriteLine(domain);
allSites.Add(domain);
}
// Add all domain aliases
DataSet aliases = SiteDomainAliasInfoProvider.GetDomainAliases("SiteID=" + ValidationHelper.GetString(dr["SiteID"], ""), null, "SiteDomainAliasName");
if (!DataHelper.DataSourceIsEmpty(aliases))
{
foreach (DataRow drAlias in aliases.Tables[0].Rows)
{
// Get domain
domain = ValidationHelper.GetString(drAlias["SiteDomainAliasName"], "");
if (!string.IsNullOrEmpty(domain))
{
domain = GetDomain(domain);
// Add to file
if (!allSites.Contains(domain))
{
sw.WriteLine(domain);
allSites.Add(domain);
}
}
}
}
}
}
}
}
}
// Output
string downloadPath = ImportExportHelper.GetSiteUtilsFolderRelativePath();
string location = null;
// Path is relative path
if (downloadPath != null)
{
string externalUrl = null;
string fullPath = downloadPath + "Export/" + fileName;
// Handle external storage URL
if (StorageHelper.IsExternalStorage(fullPath))
{
externalUrl = File.GetFileUrl(fullPath, CMSContext.CurrentSiteName);
}
// Handle default URL
if (string.IsNullOrEmpty(externalUrl))
{
location = URLHelper.ResolveUrl(downloadPath + "Export/" + fileName);
}
else
{
location = externalUrl;
}
location = String.Format("<a href=\"{0}\" target=\"_blank\">{0}</a>", location);
}
else
{
location = "<b>" + path + "</b>";
}
ShowConfirmation(GetString("license.export.exported"));
ShowInformation(String.Format(GetString("license.export.download"), location));
plcTextBox.Visible = false;
}
catch (Exception ex)
{
ShowError(ex.Message);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
backup = QueryHelper.GetBoolean("backup", false);
// Check permissions
if (backup)
{
if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.globalpermissions", "BackupObjects", CMSContext.CurrentSiteName))
{
RedirectToCMSDeskAccessDenied("cms.globalpermissions", "BackupObjects");
}
}
else if (!CMSContext.CurrentUser.IsAuthorizedPerResource("cms.globalpermissions", "ExportObjects", CMSContext.CurrentSiteName))
{
RedirectToCMSDeskAccessDenied("cms.globalpermissions", "ExportObjects");
}
// Register script for pendingCallbacks repair
ScriptHelper.FixPendingCallbacks(Page);
// Async control events binding
ucAsyncControl.OnFinished += ucAsyncControl_OnFinished;
ucAsyncControl.OnError += ucAsyncControl_OnError;
if (!IsCallback)
{
try
{
// Delete temporary files
ExportProvider.DeleteTemporaryFiles();
}
catch (Exception ex)
{
DisplayError(ex);
}
if (backup)
{
SetTitle("CMSModules/CMS_ImportExport/backupobject.png", GetString("BackupObject.Title"), null, null);
}
else
{
SetTitle("CMSModules/CMS_ImportExport/exportobject.png", GetString("ExportObject.Title"), null, null);
}
// Display BETA warning
lblBeta.Visible = CMSContext.IsBetaVersion();
lblBeta.Text = string.Format(GetString("export.BETAwarning"), CMSContext.GetFriendlySystemVersion(false));
// Get data from parameters
objectId = ValidationHelper.GetInteger(Request.QueryString["objectId"], 0);
objectType = ValidationHelper.GetString(Request.QueryString["objectType"], "");
// Get the object
infoObj = CMSObjectHelper.GetReadOnlyObject(objectType);
if (infoObj == null)
{
plcExportDetails.Visible = false;
lblIntro.Text = GetString("ExportObject.ObjectTypeNotFound");
lblIntro.CssClass = "ErrorLabel";
return;
}
// Get exported object
exportObj = infoObj.GetObject(objectId);
if (exportObj == null)
{
plcExportDetails.Visible = false;
lblIntro.Text = GetString("ExportObject.ObjectNotFound");
lblIntro.CssClass = "ErrorLabel";
btnOk.Visible = false;
return;
}
// Store display name
exportObjectDisplayName = HTMLHelper.HTMLEncode(exportObj.ObjectDisplayName);
if (backup)
{
lblIntro.Text = string.Format(GetString("BackupObject.Intro"), ResHelper.LocalizeString(exportObjectDisplayName));
}
else
{
lblIntro.Text = string.Format(GetString("ExportObject.Intro"), ResHelper.LocalizeString(exportObjectDisplayName));
}
btnOk.Click += btnOk_Click;
if (!RequestHelper.IsPostBack())
{
lblIntro.Visible = true;
lblFileName.Visible = true;
txtFileName.Text = GetExportFileName(exportObj, backup);
if (backup)
{
btnOk.Text = GetString("General.backup");
}
else
{
btnOk.Text = GetString("General.export");
}
btnCancel.Text = GetString("General.Close");
}
string path = null;
if (backup)
{
path = ImportExportHelper.GetObjectBackupFolder(exportObj);
targetFolder = Server.MapPath(path);
targetUrl = ResolveUrl(path) + "/" + txtFileName.Text;
}
else
{
targetFolder = ImportExportHelper.GetSiteUtilsFolder() + "Export";
path = ImportExportHelper.GetSiteUtilsFolderRelativePath();
if (path != null)
{
string externalUrl = null;
string fullPath = path + "Export/" + txtFileName.Text;
// Handle external storage URL
if (StorageHelper.IsExternalStorage(fullPath))
{
externalUrl = File.GetFileUrl(fullPath, CMSContext.CurrentSiteName);
}
// Ensure default target URL if not set
if (string.IsNullOrEmpty(externalUrl))
{
targetUrl = ResolveUrl(path) + "Export/" + txtFileName.Text;
}
else
{
targetUrl = externalUrl;
}
}
else
{
targetUrl = null;
}
}
}
}
/// <summary>
/// Button Ok click.
/// </summary>
/// <param name="sender">Sender</param>
/// <param name="e">Arguments</param>
protected void btnOk_Click(object sender, EventArgs e)
{
// Validate file name
string fileName = txtFileName.Text.Trim();
string errorMessage = new Validator().NotEmpty(fileName, GetString("lincense.export.filenameempty")).IsFileName(fileName, GetString("license.export.notvalidfilename")).Result;
if (!string.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
else
{
try
{
// Create writers
string path = ImportExportHelper.GetSiteUtilsFolder() + "Export\\" + fileName;
DirectoryHelper.EnsureDiskPath(path, SystemContext.WebApplicationPhysicalPath);
using (FileStream file = FileStream.New(path, FileMode.Create))
{
using (StreamWriter sw = StreamWriter.New(file))
{
// Array list for duplicity checking
ArrayList allSites = new ArrayList();
// Get all sites
DataSet sites = SiteInfoProvider.GetSites().Columns("SiteID,SiteDomainName");
if (!DataHelper.DataSourceIsEmpty(sites))
{
foreach (DataRow dr in sites.Tables[0].Rows)
{
// Get domain
string domain = ValidationHelper.GetString(dr["SiteDomainName"], "");
if (!string.IsNullOrEmpty(domain))
{
domain = GetDomain(domain);
// Add to file
if (!allSites.Contains(domain))
{
sw.WriteLine(domain);
allSites.Add(domain);
}
// Add all domain aliases
DataSet aliases = SiteDomainAliasInfoProvider.GetDomainAliases()
.Column("SiteDomainAliasName")
.Where("SiteID", QueryOperator.Equals, ValidationHelper.GetInteger(dr["SiteID"], 0));
if (!DataHelper.DataSourceIsEmpty(aliases))
{
foreach (DataRow drAlias in aliases.Tables[0].Rows)
{
// Get domain
domain = ValidationHelper.GetString(drAlias["SiteDomainAliasName"], "");
if (!string.IsNullOrEmpty(domain))
{
domain = GetDomain(domain);
// Add to file
if (!allSites.Contains(domain))
{
sw.WriteLine(domain);
allSites.Add(domain);
}
}
}
}
}
}
}
}
}
// Output
string url = ImportExportHelper.GetExportPackageUrl(fileName, SiteContext.CurrentSiteName);
string downloadLink = (url != null) ? String.Format("<a href=\"{0}\" target=\"_blank\">{1}</a>", url, GetString("license.export.clicktodownload")) : "";
string storageName = (StorageHelper.IsExternalStorage(path)) ? GetString("Export.StorageProviderName." + StorageHelper.GetStorageProvider(path).Name) : "";
string relativePath = ImportExportHelper.GetSiteUtilsFolderRelativePath() + "Export/" + txtFileName.Text;
ShowConfirmation(GetString("license.export.exported"));
ShowInformation(String.Format(GetString("license.export.download"), storageName, relativePath, downloadLink));
plcTextBox.Visible = false;
}
catch (Exception ex)
{
ShowError(ex.Message);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
backup = QueryHelper.GetBoolean("backup", false);
// Check permissions
if (backup)
{
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("cms.globalpermissions", "BackupObjects", SiteContext.CurrentSiteName))
{
RedirectToAccessDenied("cms.globalpermissions", "BackupObjects");
}
}
else if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("cms.globalpermissions", "ExportObjects", SiteContext.CurrentSiteName))
{
RedirectToAccessDenied("cms.globalpermissions", "ExportObjects");
}
// Register script for pendingCallbacks repair
ScriptHelper.FixPendingCallbacks(Page);
// Async control events binding
ucAsyncControl.OnFinished += ucAsyncControl_OnFinished;
ucAsyncControl.OnError += ucAsyncControl_OnError;
if (!RequestHelper.IsCallback())
{
try
{
// Delete temporary files
ExportProvider.DeleteTemporaryFiles();
}
catch (Exception ex)
{
DisplayError(ex);
}
if (backup)
{
SetTitle(GetString("BackupObject.Title"));
}
else
{
SetTitle(GetString("ExportObject.Title"));
}
// Display BETA warning
lblBeta.Visible = CMSVersion.IsBetaVersion();
lblBeta.Text = string.Format(GetString("export.BETAwarning"), CMSVersion.GetFriendlySystemVersion(false));
// Get data from parameters
objectId = QueryHelper.GetInteger("objectId", 0);
objectType = QueryHelper.GetString("objectType", "");
// Get the object
infoObj = ModuleManager.GetReadOnlyObject(objectType);
if (infoObj == null)
{
plcExportDetails.Visible = false;
lblIntro.Text = GetString("ExportObject.ObjectTypeNotFound");
lblIntro.CssClass = "ErrorLabel";
return;
}
// Get exported object
exportObj = infoObj.GetObject(objectId);
if (exportObj == null)
{
plcExportDetails.Visible = false;
lblIntro.Text = GetString("ExportObject.ObjectNotFound");
lblIntro.CssClass = "ErrorLabel";
btnOk.Visible = false;
return;
}
// Check permissions
var info = (BaseInfo)exportObj;
if (!CurrentUser.IsGlobalAdministrator)
{
try
{
if (info.Generalized.ObjectSiteID > 0)
{
CurrentUser.IsAuthorizedPerObject(PermissionsEnum.Read, info,
SiteInfoProvider.GetSiteName(info.Generalized.ObjectSiteID), true);
}
else if ((info.TypeInfo.SiteBindingObject != null) && (info.AssignedSites[CurrentSiteName] == null))
{
// Do not allow to clone objects with site binding which are not assigned to current site
RedirectToAccessDenied(info.TypeInfo.ModuleName, PermissionsEnum.Read.ToString());
}
else
{
CurrentUser.IsAuthorizedPerObject(PermissionsEnum.Read, info, CurrentSiteName, true);
}
}
catch (PermissionCheckException ex)
{
RedirectToAccessDenied(ex.ModuleName, ex.PermissionFailed);
}
}
// Store display name
exportObjectDisplayName = HTMLHelper.HTMLEncode(ResHelper.LocalizeString(exportObj.ObjectDisplayName));
lblIntro.Text = string.Format(GetString(backup ? "BackupObject.Intro" : "ExportObject.Intro"), exportObjectDisplayName);
btnOk.Click += btnOk_Click;
if (!RequestHelper.IsPostBack())
{
lblIntro.Visible = true;
lblFileName.Visible = true;
txtFileName.Text = GetExportFileName(exportObj, backup);
}
btnOk.Text = GetString(backup ? "General.backup" : "General.export");
string path;
if (backup)
{
path = ImportExportHelper.GetObjectBackupFolder(exportObj);
targetFolder = Server.MapPath(path);
targetUrl = ResolveUrl(path) + "/" + txtFileName.Text;
}
else
{
targetFolder = ImportExportHelper.GetSiteUtilsFolder() + "Export";
path = ImportExportHelper.GetSiteUtilsFolderRelativePath();
if (path != null)
{
string externalUrl = null;
string fullPath = path + "Export/" + txtFileName.Text;
// Handle external storage URL
if (StorageHelper.IsExternalStorage(fullPath))
{
externalUrl = File.GetFileUrl(fullPath, SiteContext.CurrentSiteName);
}
// Ensure default target URL if not set
if (string.IsNullOrEmpty(externalUrl))
{
targetUrl = ResolveUrl(path) + "Export/" + txtFileName.Text;
}
else
{
targetUrl = externalUrl;
}
}
else
{
targetUrl = null;
}
}
}
}
/// <summary>
/// Imports licenses from file.
/// </summary>
/// <param name="parameter">Parameter</param>
private void ImportLicenses(object parameter)
{
// Inform about start
ImportManager.Settings.LogProgressState(LogStatusEnum.Info, GetString("license.import.started"));
// Get selected value and ensure that file exists
string file = lstImports.SelectedValue;
string path = ImportExportHelper.GetSiteUtilsFolder() + "Import\\" + lstImports.SelectedValue;
if (File.Exists(path))
{
using (FileStream fs = FileStream.New(path, FileMode.Open, FileAccess.Read))
{
using (StreamReader sr = StreamReader.New(fs))
{
string license = string.Empty;
bool licenseInserted = true;
while (sr.Peek() >= 0)
{
// Test if user clicked cancel button
if (ImportManager.Settings.ProcessCanceled)
{
licenseInserted = true;
ImportManager.Settings.LogProgressState(LogStatusEnum.Finish, GetString("license.import.canceled"));
break;
}
// Read line and check if it's blank line
string line = sr.ReadLine();
if (string.IsNullOrEmpty(line))
{
// Insert license
if (!licenseInserted)
{
InsertLicense(license);
licenseInserted = true;
license = String.Empty;
}
}
else
{
licenseInserted = false;
license += line + '\n';
}
}
// Insert license
if (!licenseInserted)
{
InsertLicense(license);
}
}
}
// Clear hashtables
CMS.SiteProvider.UserInfoProvider.ClearLicenseValues();
Functions.ClearHashtables();
if (!ImportManager.Settings.ProcessCanceled)
{
ImportManager.Settings.LogProgressState(LogStatusEnum.Finish, GetString("license.import.finish"));
}
}
}
/// <summary>
/// Create&Delete directory/file test.
/// </summary>
/// <param name="path">Path where to create subdirectory</param>
/// <param name="di">Parent directory info</param>
protected void CreateDeleteTest(string path, DirectoryInfo di)
{
FileInfo fi = null;
DirectoryInfo sdi = null;
string strCreating = GetString("System_Files.Creating");
string strDeleting = GetString("System_Files.Deleting");
string strOK = GetString("General.OK");
string strFailed = GetString("System_Files.Failed");
string targetPath = ImportExportHelper.GetSiteUtilsFolderRelativePath();
DateTime dt = DateTime.Now;
// Create subdirectory name
string subdir = "TestFolder" + dt.Year.ToString() + dt.Month.ToString() + dt.Day.ToString() +
dt.Hour.ToString() + dt.Minute.ToString() + dt.Second.ToString();
// Path is full path
if (targetPath == null)
{
targetPath = ImportExportHelper.GetSiteUtilsFolder() + DirectoryHelper.CombinePath("TestFiles", subdir) + "\\";
}
else
{
targetPath = targetPath + "TestFiles/" + subdir + "/";
}
ltlInfo.Text += strCreating + " '" + targetPath + "' - ";
try
{
// Create subdirectory
sdi = di.CreateSubdirectory(subdir);
ltlInfo.Text += strOK;
}
catch
{
ltlInfo.Text += strFailed;
}
// Create test file name
string fileName = "TestFile" + dt.Year.ToString() + dt.Month.ToString() + dt.Day.ToString() +
dt.Hour.ToString() + dt.Minute.ToString() + dt.Second.ToString() + ".txt";
ltlInfo.Text += "<br /><br />" + strCreating + " '" + targetPath + fileName + "' - ";
try
{
// Create test file
fi = FileInfo.New(path + subdir + "/" + fileName);
using (StreamWriter sw = fi.CreateText())
{
sw.WriteLine("Edited - " + dt.ToString());
}
ltlInfo.Text += strOK;
}
catch
{
ltlInfo.Text += strFailed;
}
ltlInfo.Text += "<br /><br />" + strDeleting + " '" + targetPath + fileName + "' - ";
try
{
// Delete test file
fi.Delete();
ltlInfo.Text += strOK;
}
catch
{
ltlInfo.Text += strFailed;
}
ltlInfo.Text += "<br /><br />" + strDeleting + " '" + targetPath + "' - ";
try
{
// Delete subdirectory
sdi.Delete();
ltlInfo.Text += strOK;
}
catch
{
ltlInfo.Text += strFailed;
}
}
/// <summary>
/// Gets the path to the location of the package based on provided package <see cref="metadata"/>.
/// </summary>
/// <param name="metadata">Metadata of the package</param>
private string GetPackageFilePath(ModulePackageMetadata metadata)
{
var packageName = String.Format("{0}.{1}.nupkg", metadata.Id, metadata.Version);
return(Path.EnsureSlashes(Path.Combine(ImportExportHelper.GetSiteUtilsFolder(), "Export", packageName)));
}
