public static PackageWriterBase GetWriter(PackageInfo package)
{
PackageWriterBase writer = null;
switch (package.PackageType)
{
case "Auth_System":
writer = new AuthenticationPackageWriter(package);
break;
case "Module":
writer = new ModulePackageWriter(package);
break;
case "Container":
writer = new ContainerPackageWriter(package);
break;
case "Skin":
writer = new SkinPackageWriter(package);
break;
case "CoreLanguagePack":
case "ExtensionLanguagePack":
writer = new LanguagePackWriter(package);
break;
case "SkinObject":
writer = new SkinControlPackageWriter(package);
break;
case "Provider":
writer = new ProviderPackageWriter(package);
break;
case "Library":
writer = new LibraryPackageWriter(package);
break;
case "Widget":
writer = new WidgetPackageWriter(package);
break;
default:
CommonLibrary.Common.Lists.ListController listController = new CommonLibrary.Common.Lists.ListController();
ListEntryInfo entry = listController.GetListEntryInfo("PackageWriter", package.PackageType);
if (entry != null && !string.IsNullOrEmpty(entry.Text))
{
writer = (PackageWriterBase)Reflection.CreateObject(entry.Text, "PackageWriter_" + entry.Value);
}
break;
}
return(writer);
}
public static string CreateSkinManifest(string skinFolder, string skinType, string tempInstallFolder)
{
// Test if there are Skins and Containers folders in TempInstallFolder (ie it is a legacy combi package)
bool isCombi = false;
var installFolder = new DirectoryInfo(tempInstallFolder);
DirectoryInfo[] subFolders = installFolder.GetDirectories();
if (subFolders.Length > 0)
{
if (subFolders[0].Name.Equals("containers", StringComparison.InvariantCultureIgnoreCase) || subFolders[0].Name.Equals("skins", StringComparison.InvariantCultureIgnoreCase))
{
isCombi = true;
}
}
// Create a writer to create the processed manifest
var sb = new StringBuilder();
using (XmlWriter writer = XmlWriter.Create(sb, XmlUtils.GetXmlWriterSettings(ConformanceLevel.Fragment)))
{
PackageWriterBase.WriteManifestStartElement(writer);
if (isCombi)
{
if (Directory.Exists(Path.Combine(tempInstallFolder, "Skins")))
{
// Add Skin Package Fragment
CreateSkinManifest(writer, skinFolder, "Skin", tempInstallFolder.Replace(Globals.ApplicationMapPath + "\\", string.Empty), "Skins");
}
if (Directory.Exists(Path.Combine(tempInstallFolder, "Containers")))
{
// Add Container PAckage Fragment
CreateSkinManifest(writer, skinFolder, "Container", tempInstallFolder.Replace(Globals.ApplicationMapPath + "\\", string.Empty), "Containers");
}
}
else
{
// Add Package Fragment
CreateSkinManifest(writer, skinFolder, skinType, tempInstallFolder.Replace(Globals.ApplicationMapPath + "\\", string.Empty), string.Empty);
}
PackageWriterBase.WriteManifestEndElement(writer);
// Close XmlWriter
writer.Close();
// Return new manifest
return(sb.ToString());
}
}
public static string CreateSkinManifest(string skinFolder, string skinType, string tempInstallFolder)
{
bool isCombi = false;
DirectoryInfo installFolder = new DirectoryInfo(tempInstallFolder);
DirectoryInfo[] subFolders = installFolder.GetDirectories();
if (subFolders.Length > 0)
{
if ((subFolders[0].Name.ToLowerInvariant() == "containers" || subFolders[0].Name.ToLowerInvariant() == "skins"))
{
isCombi = true;
}
}
StringBuilder sb = new StringBuilder();
XmlWriter writer = XmlWriter.Create(sb, XmlUtils.GetXmlWriterSettings(ConformanceLevel.Fragment));
PackageWriterBase.WriteManifestStartElement(writer);
if (isCombi)
{
if (Directory.Exists(Path.Combine(tempInstallFolder, "Skins")))
{
CreateSkinManifest(writer, skinFolder, "Skin", tempInstallFolder.Replace(Globals.ApplicationMapPath + "\\", ""), "Skins");
}
if (Directory.Exists(Path.Combine(tempInstallFolder, "Containers")))
{
CreateSkinManifest(writer, skinFolder, "Container", tempInstallFolder.Replace(Globals.ApplicationMapPath + "\\", ""), "Containers");
}
}
else
{
CreateSkinManifest(writer, skinFolder, skinType, tempInstallFolder.Replace(Globals.ApplicationMapPath + "\\", ""), "");
}
PackageWriterBase.WriteManifestEndElement(writer);
writer.Close();
return(sb.ToString());
}
public static XPathNavigator ConvertLegacyNavigator(XPathNavigator rootNav, InstallerInfo info)
{
XPathNavigator nav = null;
var packageType = Null.NullString;
if (rootNav.Name == "dotnetnuke")
{
packageType = Util.ReadAttribute(rootNav, "type");
}
else if (rootNav.Name.ToLower() == "languagepack")
{
packageType = "LanguagePack";
}
XPathDocument legacyDoc;
string legacyManifest;
switch (packageType.ToLower())
{
case "module":
var sb = new StringBuilder();
var writer = XmlWriter.Create(sb, XmlUtils.GetXmlWriterSettings(ConformanceLevel.Fragment));
//Write manifest start element
PackageWriterBase.WriteManifestStartElement(writer);
//Legacy Module - Process each folder
foreach (XPathNavigator folderNav in rootNav.Select("folders/folder"))
{
var modulewriter = new ModulePackageWriter(folderNav, info);
modulewriter.WriteManifest(writer, true);
}
//Write manifest end element
PackageWriterBase.WriteManifestEndElement(writer);
//Close XmlWriter
writer.Close();
//Load manifest into XPathDocument for processing
legacyDoc = new XPathDocument(new StringReader(sb.ToString()));
//Parse the package nodes
nav = legacyDoc.CreateNavigator().SelectSingleNode("dotnetnuke");
break;
case "languagepack":
//Legacy Language Pack
var languageWriter = new LanguagePackWriter(rootNav, info);
info.LegacyError = languageWriter.LegacyError;
if (string.IsNullOrEmpty(info.LegacyError))
{
legacyManifest = languageWriter.WriteManifest(false);
legacyDoc = new XPathDocument(new StringReader(legacyManifest));
//Parse the package nodes
nav = legacyDoc.CreateNavigator().SelectSingleNode("dotnetnuke");
}
break;
case "skinobject":
//Legacy Skin Object
var skinControlwriter = new SkinControlPackageWriter(rootNav, info);
legacyManifest = skinControlwriter.WriteManifest(false);
legacyDoc = new XPathDocument(new StringReader(legacyManifest));
//Parse the package nodes
nav = legacyDoc.CreateNavigator().SelectSingleNode("dotnetnuke");
break;
}
return(nav);
}
private void BindData()
{
email.ValidationExpression = Globals.glbEmailRegEx;
trLanguagePackType.Visible = false;
switch (Mode)
{
case "All":
lblHelp.Text = Localization.GetString("EditHelp", LocalResourceFile);
cmdUpdate.Text = Localization.GetString("cmdUpdate", LocalResourceFile);
break;
case "LanguagePack":
lblHelp.Text = Localization.GetString("EditLanguageHelp", LocalResourceFile);
cmdUpdate.Text = Localization.GetString("cmdUpdateLanguage", LocalResourceFile);
break;
case "Module":
lblHelp.Text = Localization.GetString("EditModuleHelp", LocalResourceFile);
cmdUpdate.Text = Localization.GetString("cmdUpdateModule", LocalResourceFile);
break;
case "Skin":
lblHelp.Text = Localization.GetString("EditSkinHelp", LocalResourceFile);
cmdUpdate.Text = Localization.GetString("cmdUpdateSkin", LocalResourceFile);
break;
}
cmdPackage.Visible = IsSuperTab;
cmdUpdate.Visible = IsSuperTab;
if (Package != null)
{
if (PackageEditor == null || PackageID == Null.NullInteger)
{
extensionSection.Visible = false;
}
else
{
phEditor.Controls.Clear();
phEditor.Controls.Add(PackageEditor as Control);
var moduleControl = PackageEditor as IModuleControl;
if (moduleControl != null)
{
moduleControl.ModuleContext.Configuration = ModuleContext.Configuration;
}
PackageEditor.PackageID = PackageID;
PackageEditor.Initialize();
Package.IconFile = Util.ParsePackageIconFileName(Package);
}
switch (Package.PackageType)
{
case "Auth_System":
case "Container":
case "Module":
case "Skin":
iconFile.Enabled = true;
Package.IconFile = Util.ParsePackageIconFileName(Package);
break;
default:
iconFile.Enabled = false;
Package.IconFile = "Not Available";
break;
}
if (Mode != "All")
{
packageType.Visible = false;
}
//Determine if Package is ready for packaging
PackageWriterBase writer = PackageWriterFactory.GetWriter(Package);
cmdPackage.Visible = IsSuperTab && writer != null && Directory.Exists(Path.Combine(Globals.ApplicationMapPath, writer.BasePath));
cmdDelete.Visible = IsSuperTab && (!Package.IsSystemPackage) && (PackageController.CanDeletePackage(Package, ModuleContext.PortalSettings));
ctlAudit.Entity = Package;
packageForm.DataSource = Package;
packageFormReadOnly.DataSource = Package;
if (!Page.IsPostBack)
{
packageForm.DataBind();
packageFormReadOnly.DataBind();
}
packageForm.Visible = IsSuperTab;
packageFormReadOnly.Visible = !IsSuperTab;
}
}
private void ReadManifest(Stream stream)
{
XPathDocument doc = new XPathDocument(stream);
XPathNavigator rootNav = doc.CreateNavigator();
XPathDocument legacyDoc = null;
rootNav.MoveToFirstChild();
string packageType = Null.NullString;
string legacyManifest = Null.NullString;
if (rootNav.Name == "CommonLibrary")
{
packageType = Util.ReadAttribute(rootNav, "type");
}
else if (rootNav.Name.ToLower() == "languagepack")
{
packageType = "LanguagePack";
}
else
{
InstallerInfo.Log.AddFailure(Util.PACKAGE_UnRecognizable);
}
switch (packageType.ToLower())
{
case "package":
InstallerInfo.IsLegacyMode = false;
ProcessPackages(rootNav);
break;
case "module":
InstallerInfo.IsLegacyMode = true;
StringBuilder sb = new StringBuilder();
XmlWriter writer = XmlWriter.Create(sb, XmlUtils.GetXmlWriterSettings(ConformanceLevel.Fragment));
PackageWriterBase.WriteManifestStartElement(writer);
foreach (XPathNavigator folderNav in rootNav.Select("folders/folder"))
{
ModulePackageWriter modulewriter = new ModulePackageWriter(folderNav, InstallerInfo);
modulewriter.WriteManifest(writer, true);
}
PackageWriterBase.WriteManifestEndElement(writer);
writer.Close();
legacyDoc = new XPathDocument(new StringReader(sb.ToString()));
ProcessPackages(legacyDoc.CreateNavigator().SelectSingleNode("CommonLibrary"));
break;
case "languagepack":
InstallerInfo.IsLegacyMode = true;
LanguagePackWriter languageWriter = new LanguagePackWriter(rootNav, InstallerInfo);
LegacyError = languageWriter.LegacyError;
if (string.IsNullOrEmpty(LegacyError))
{
legacyManifest = languageWriter.WriteManifest(false);
legacyDoc = new XPathDocument(new StringReader(legacyManifest));
ProcessPackages(legacyDoc.CreateNavigator().SelectSingleNode("CommonLibrary"));
}
break;
case "skinobject":
InstallerInfo.IsLegacyMode = true;
SkinControlPackageWriter skinControlwriter = new SkinControlPackageWriter(rootNav, InstallerInfo);
legacyManifest = skinControlwriter.WriteManifest(false);
legacyDoc = new XPathDocument(new StringReader(legacyManifest));
ProcessPackages(legacyDoc.CreateNavigator().SelectSingleNode("CommonLibrary"));
break;
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The Page_Load runs when the page loads
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 01/31/2008 Created
/// </history>
/// -----------------------------------------------------------------------------
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
chkUseManifest.CheckedChanged += chkUseManifest_CheckedChanged;
cmdGetFiles.Click += cmdGetFiles_Click;
wizPackage.ActiveStepChanged += wizPackage_ActiveStepChanged;
wizPackage.CancelButtonClick += wizPackage_CancelButtonClick;
wizPackage.FinishButtonClick += wizPackage_FinishButtonClick;
wizPackage.NextButtonClick += wizPackage_NextButtonClick;
try
{
CheckSecurity();
ctlPackage.EditMode = PropertyEditorMode.View;
switch (Package.PackageType)
{
case "CoreLanguagePack":
Package.IconFile = "N\\A";
break;
default:
Package.IconFile = Util.ParsePackageIconFileName(Package);
break;
}
ctlPackage.DataSource = Package;
ctlPackage.DataBind();
_Writer = PackageWriterFactory.GetWriter(Package);
if (Page.IsPostBack)
{
_Writer.BasePath = txtBasePath.Text;
}
else
{
txtBasePath.Text = _Writer.BasePath;
//Load Manifests
if (!string.IsNullOrEmpty(Package.Manifest))
{
cboManifests.Items.Add(new ListItem("Database version", ""));
}
string filePath = Server.MapPath(_Writer.BasePath);
if (!string.IsNullOrEmpty(filePath))
{
if (Directory.Exists(filePath))
{
foreach (string file in Directory.GetFiles(filePath, "*.dnn"))
{
string fileName = file.Replace(filePath + "\\", "");
cboManifests.Items.Add(new ListItem(fileName, fileName));
}
foreach (string file in Directory.GetFiles(filePath, "*.dnn.resources"))
{
string fileName = file.Replace(filePath + "\\", "");
cboManifests.Items.Add(new ListItem(fileName, fileName));
}
}
}
if (cboManifests.Items.Count > 0)
{
trUseManifest.Visible = true;
}
}
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
protected void imbCreatePackage_Click(object sender, EventArgs e)
{
string FullFilePath = "";
List <FileDetails> selectedFiles = new List <FileDetails>();
List <FileDetails> selectedResxFiles = GetSelectedLanguageFiles(this.ddlResourceLocale.SelectedValue.ToString(), selectedFiles, "~/Modules", "*.resx");
selectedResxFiles = GetSelectedLanguageFiles(this.ddlResourceLocale.SelectedValue.ToString(), selectedResxFiles, "~/Modules", "*.js");
selectedResxFiles = GetSelectedLanguageFiles(this.ddlResourceLocale.SelectedValue.ToString(), selectedResxFiles, "~/XMLMessage", "*.xml");
selectedResxFiles = GetSelectedLanguageFiles(this.ddlResourceLocale.SelectedValue.ToString(), selectedResxFiles, "~/Modules", "*.xml");
string filepath = Server.MapPath("~/Install/Language");
if (!Directory.Exists(filepath))
{
Directory.CreateDirectory(filepath);
}
///Get the application version
SageFrame.Application.Application app = new SageFrame.Application.Application();
app.FormatVersion(app.Version, true);
StringBuilder fileNameSB = new StringBuilder();
fileNameSB.Append("ResourcePack.");
fileNameSB.Append(txtResourcePackName.Text);
fileNameSB.Append(".");
fileNameSB.Append(app.Version.ToString());
fileNameSB.Append(".");
fileNameSB.Append(ddlResourceLocale.SelectedValue.ToString());
string fileName = fileNameSB.ToString();
List <FileDetails> newFileList = new List <FileDetails>();
switch (rbResourcePackType.SelectedIndex)
{
case 0:
newFileList = GetCoreModuleResources(selectedResxFiles);;
break;
case 1:
GetSelectedModules(ref newFileList, selectedResxFiles);
break;
case 2:
newFileList = selectedResxFiles;
break;
}
try
{
PackageWriterBase.WriteManifest(filepath, "manifest", newFileList, GetPackageInfo());
PackageWriterBase.WriteZipFile(newFileList, filepath + @"/" + fileName + ".zip", filepath + @"\manifest.sfe", "manifest.sfe");
FullFilePath = string.Format("{0}/{1}.zip", filepath, fileName);
ViewState["FilePath"] = FullFilePath;
if (File.Exists(FullFilePath))
{
Response.ClearContent();
Response.AppendHeader("Content-Disposition", "attachment; filename=" + fileName + ".zip");
Response.ContentType = "application/octet-stream";
using (Stream input = File.OpenRead(FullFilePath))
{
byte[] buffer = new byte[4096];
int count = input.Read(buffer, 0, buffer.Length);
while (count > 0)
{
Response.OutputStream.Write(buffer, 0, count);
count = input.Read(buffer, 0, buffer.Length);
}
}
ShowMessage("", GetSageMessage("LanguageModule", "PackageCreatedSuccessfully"), "", SageMessageType.Success);
File.Delete(FullFilePath);
}
if (rbResourcePackType.SelectedIndex == 1)
{
divModuleDetails.Visible = true;
}
}
catch (Exception ex)
{
ProcessException(ex);
}
finally
{
Response.End();
}
}
