public SkinControlPackageWriter(SkinControlInfo skinControl, PackageInfo package)
: base(package)
{
_SkinControl = skinControl;
BasePath = Path.Combine("DesktopModules", package.Name.ToLower()).Replace("/", "\\");
AppCodePath = Path.Combine("App_Code", package.Name.ToLower()).Replace("/", "\\");
}
public SkinControlPackageWriter(PackageInfo package)
: base(package)
{
_SkinControl = SkinControlController.GetSkinControlByPackageID(package.PackageID);
BasePath = Path.Combine("DesktopModules", package.Name.ToLower()).Replace("/", "\\");
AppCodePath = Path.Combine("App_Code", package.Name.ToLower()).Replace("/", "\\");
}
public SkinPackageWriter(SkinPackageInfo skinPackage, PackageInfo package, string basePath, string subFolder)
: base(package)
{
_SkinPackage = skinPackage;
_SubFolder = subFolder;
this.BasePath = Path.Combine(basePath, subFolder);
}
public LanguageComponentWriter(LanguagePackInfo languagePack, string basePath, Dictionary<string, InstallFile> files, PackageInfo package)
: base(basePath, files, package)
{
_Language = Localization.Localization.GetLocaleByID(languagePack.LanguageID);
_PackageType = languagePack.PackageType;
_DependentPackageID = languagePack.DependentPackageID;
}
private static void ParsePackageName(PackageInfo package, string separator)
{
int ownerIndex = package.Name.IndexOf(separator);
if (ownerIndex > 0)
{
package.Owner = package.Name.Substring(0, ownerIndex);
}
}
public PackageInstaller(string packageManifest, InstallerInfo info)
{
Package = new PackageInfo(info);
Package.Manifest = packageManifest;
if (!string.IsNullOrEmpty(packageManifest))
{
XPathDocument doc = new XPathDocument(new StringReader(packageManifest));
XPathNavigator nav = doc.CreateNavigator().SelectSingleNode("package");
ReadManifest(nav);
}
}
private static PackageInfo CreateSkinPackage(SkinPackageInfo skin)
{
PackageInfo package = new PackageInfo(new InstallerInfo());
package.Name = skin.SkinName;
package.FriendlyName = skin.SkinName;
package.Description = Null.NullString;
package.Version = new Version(1, 0, 0);
package.PackageType = skin.SkinType;
package.License = Util.PACKAGE_NoLicense;
ParsePackageName(package);
return package;
}
public SkinControlPackageWriter(XPathNavigator manifestNav, InstallerInfo installer)
{
_SkinControl = new SkinControlInfo();
Package = new PackageInfo(installer);
ReadLegacyManifest(manifestNav, true);
Package.Description = Null.NullString;
Package.Version = new Version(1, 0, 0);
Package.PackageType = "SkinObject";
Package.License = Util.PACKAGE_NoLicense;
BasePath = Path.Combine("DesktopModules", Package.Name.ToLower()).Replace("/", "\\");
AppCodePath = Path.Combine("App_Code", Package.Name.ToLower()).Replace("/", "\\");
}
public ModulePackageWriter(DesktopModuleInfo desktopModule, XPathNavigator manifestNav, PackageInfo package)
: base(package)
{
_DesktopModule = desktopModule;
Initialize(desktopModule.FolderName);
if (manifestNav != null)
{
ReadLegacyManifest(manifestNav.SelectSingleNode("folders/folder"), false);
}
string physicalFolderPath = Path.Combine(Globals.ApplicationMapPath, BasePath);
ProcessModuleFolders(physicalFolderPath, physicalFolderPath);
}
public ProviderPackageWriter(PackageInfo package)
: base(package)
{
XmlDocument configDoc = Config.Load();
XPathNavigator providerNavigator = configDoc.CreateNavigator().SelectSingleNode("/configuration/dotnetnuke/*/providers/add[@name='" + package.Name + "']");
string providerPath = Null.NullString;
if (providerNavigator != null)
{
providerPath = Util.ReadAttribute(providerNavigator, "providerPath");
}
if (!string.IsNullOrEmpty(providerPath))
{
BasePath = providerPath.Replace("~/", "").Replace("/", "\\");
}
}
public ModulePackageWriter(XPathNavigator manifestNav, InstallerInfo installer)
{
_DesktopModule = new DesktopModuleInfo();
Package = new PackageInfo(installer);
ReadLegacyManifest(manifestNav, true);
Package.Name = DesktopModule.ModuleName;
Package.FriendlyName = DesktopModule.FriendlyName;
Package.Description = DesktopModule.Description;
if (!string.IsNullOrEmpty(DesktopModule.Version))
{
Package.Version = new Version(DesktopModule.Version);
}
Package.PackageType = "Module";
LegacyUtil.ParsePackageName(Package);
Initialize(DesktopModule.FolderName);
}
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 PackageInstaller(PackageInfo package)
{
this.Package = package;
if (!string.IsNullOrEmpty(package.Manifest))
{
XPathDocument doc = new XPathDocument(new StringReader(package.Manifest));
XPathNavigator nav = doc.CreateNavigator().SelectSingleNode("package");
ReadComponents(nav);
}
else
{
ComponentInstallerBase installer = InstallerFactory.GetInstaller(package.PackageType);
if (installer != null)
{
installer.Package = package;
installer.Type = package.PackageType;
ComponentInstallers.Add(0, installer);
}
}
}
public LanguagePackWriter(PackageInfo package)
: base(package)
{
_LanguagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID);
if (LanguagePack != null)
{
_Language = Localization.Localization.GetLocaleByID(_LanguagePack.LanguageID);
if (LanguagePack.PackageType == LanguagePackType.Core)
{
BasePath = Null.NullString;
}
else
{
PackageInfo dependendentPackage = PackageController.GetPackage(LanguagePack.DependentPackageID);
PackageWriterBase dependentPackageWriter = PackageWriterFactory.GetWriter(dependendentPackage);
BasePath = dependentPackageWriter.BasePath;
}
}
else
{
BasePath = Null.NullString;
}
}
public static ComponentInstallerBase GetInstaller(XPathNavigator manifestNav, PackageInfo package)
{
string installerType = Util.ReadAttribute(manifestNav, "type");
string componentVersion = Util.ReadAttribute(manifestNav, "version");
ComponentInstallerBase installer = GetInstaller(installerType);
if (installer != null)
{
installer.Package = package;
installer.Type = installerType;
if (!string.IsNullOrEmpty(componentVersion))
{
installer.Version = new Version(componentVersion);
}
else
{
installer.Version = package.Version;
}
if (package.InstallerInfo.InstallMode != InstallMode.ManifestOnly || installer.SupportsManifestOnlyInstall)
{
installer.ReadManifest(manifestNav);
}
}
return installer;
}
public LanguagePackWriter(XPathNavigator manifestNav, InstallerInfo installer)
{
_Language = new Locale();
XPathNavigator cultureNav = manifestNav.SelectSingleNode("Culture");
_Language.Text = Util.ReadAttribute(cultureNav, "DisplayName");
_Language.Code = Util.ReadAttribute(cultureNav, "Code");
_Language.Fallback = Services.Localization.Localization.SystemLocale;
Package = new PackageInfo(installer);
Package.Name = Language.Text;
Package.FriendlyName = Language.Text;
Package.Description = Null.NullString;
Package.Version = new Version(1, 0, 0);
Package.License = Util.PACKAGE_NoLicense;
ReadLegacyManifest(manifestNav);
if (_IsCore)
{
Package.PackageType = "CoreLanguagePack";
}
else
{
Package.PackageType = "ExtensionLanguagePack";
}
BasePath = Null.NullString;
}
private static void UpgradeToVersion_513()
{
//Ensure that default language is present (not neccessarily enabled)
Locale defaultLanguage = Localization.Localization.GetLocale("en-US");
if (defaultLanguage == null)
{
defaultLanguage = new Locale();
}
defaultLanguage.Code = "en-US";
defaultLanguage.Text = "English (United States)";
Localization.Localization.SaveLanguage(defaultLanguage);
//Ensure that there is a Default Authorization System
PackageInfo package = PackageController.GetPackageByName("DefaultAuthentication");
if (package == null)
{
package = new PackageInfo();
package.Name = "DefaultAuthentication";
package.FriendlyName = "Default Authentication";
package.Description = "The Default UserName/Password Authentication System for DotNetNuke.";
package.PackageType = "Auth_System";
package.Version = new Version(1, 0, 0);
package.Owner = "DotNetNuke";
package.License = Localization.Localization.GetString("License", Localization.Localization.GlobalResourceFile);
package.Organization = "DotNetNuke Corporation";
package.Url = "www.dotnetnuke.com";
package.Email = "*****@*****.**";
package.ReleaseNotes = "There are no release notes for this version.";
package.IsSystemPackage = true;
PackageController.SavePackage(package);
//Add Authentication System
Authentication.AuthenticationInfo authSystem = Authentication.AuthenticationController.GetAuthenticationServiceByType("DNN");
if (authSystem == null)
{
authSystem = new Authentication.AuthenticationInfo();
}
authSystem.PackageID = package.PackageID;
authSystem.AuthenticationType = "DNN";
authSystem.SettingsControlSrc = "DesktopModules/AuthenticationServices/DNN/Settings.ascx";
authSystem.LoginControlSrc = "DesktopModules/AuthenticationServices/DNN/Login.ascx";
authSystem.IsEnabled = true;
if (authSystem.AuthenticationID == Null.NullInteger)
{
Authentication.AuthenticationController.AddAuthentication(authSystem);
}
else
{
Authentication.AuthenticationController.UpdateAuthentication(authSystem);
}
}
}
public SkinPackageWriter(SkinPackageInfo skinPackage, PackageInfo package, string basePath)
: base(package)
{
_SkinPackage = skinPackage;
this.BasePath = basePath;
}
public SkinPackageWriter(SkinPackageInfo skinPackage, PackageInfo package)
: base(package)
{
_SkinPackage = skinPackage;
SetBasePath();
}
public SkinPackageWriter(PackageInfo package)
: base(package)
{
_SkinPackage = SkinController.GetSkinByPackageID(package.PackageID);
SetBasePath();
}
public LanguagePackWriter(Locale language, PackageInfo package)
: base(package)
{
_Language = language;
BasePath = Null.NullString;
}
public ContainerPackageWriter(SkinPackageInfo skinPackage, PackageInfo package)
: base(skinPackage, package)
{
BasePath = "Portals\\_default\\Containers\\" + skinPackage.SkinName;
}
public override void ReadManifest(XPathNavigator manifestNav)
{
Package.Name = Util.ReadAttribute(manifestNav, "name", Log, Util.EXCEPTION_NameMissing);
Package.PackageType = Util.ReadAttribute(manifestNav, "type", Log, Util.EXCEPTION_TypeMissing);
if (Package.PackageType == "Skin" || Package.PackageType == "Container")
{
Package.PortalID = Package.InstallerInfo.PortalID;
}
CheckSecurity();
if (!IsValid)
{
return;
}
InstalledPackage = PackageController.GetPackageByName(Package.PortalID, Package.Name);
Package.IsSystemPackage = bool.Parse(Util.ReadAttribute(manifestNav, "isSystem", false, Log, "", bool.FalseString));
string strVersion = Util.ReadAttribute(manifestNav, "version", Log, Util.EXCEPTION_VersionMissing);
ValidateVersion(strVersion);
if (!IsValid)
{
return;
}
Log.AddInfo(Util.DNN_ReadingPackage + " - " + Package.PackageType + " - " + Package.Name);
Package.FriendlyName = Util.ReadElement(manifestNav, "friendlyName", Package.Name);
Package.Description = Util.ReadElement(manifestNav, "description");
XPathNavigator authorNav = manifestNav.SelectSingleNode("owner");
if (authorNav != null)
{
Package.Owner = Util.ReadElement(authorNav, "name");
Package.Organization = Util.ReadElement(authorNav, "organization");
Package.Url = Util.ReadElement(authorNav, "url");
Package.Email = Util.ReadElement(authorNav, "email");
}
XPathNavigator licenseNav = manifestNav.SelectSingleNode("license");
if (licenseNav != null)
{
string licenseSrc = Util.ReadAttribute(licenseNav, "src");
if (string.IsNullOrEmpty(licenseSrc))
{
Package.License = licenseNav.Value;
}
else
{
Package.License = ReadTextFromFile(licenseSrc);
}
}
if (string.IsNullOrEmpty(Package.License))
{
Package.License = Util.PACKAGE_NoLicense;
}
XPathNavigator relNotesNav = manifestNav.SelectSingleNode("releaseNotes");
if (relNotesNav != null)
{
string relNotesSrc = Util.ReadAttribute(relNotesNav, "src");
if (string.IsNullOrEmpty(relNotesSrc))
{
Package.ReleaseNotes = relNotesNav.Value;
}
else
{
Package.ReleaseNotes = ReadTextFromFile(relNotesSrc);
}
}
if (string.IsNullOrEmpty(Package.License))
{
Package.License = Util.PACKAGE_NoReleaseNotes;
}
IDependency dependency = null;
foreach (XPathNavigator dependencyNav in manifestNav.CreateNavigator().Select("dependencies/dependency"))
{
dependency = DependencyFactory.GetDependency(dependencyNav);
if (!dependency.IsValid)
{
Log.AddFailure(dependency.ErrorMessage);
return;
}
}
ReadComponents(manifestNav);
}
public SkinComponentWriter(string skinName, string basePath, Dictionary<string, InstallFile> files, PackageInfo package)
: base(basePath, files, package)
{
_SkinName = skinName;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// AddSkinControl adds a new Module Control to the system
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="ControlKey">The key for this control in the Definition</param>
/// <param name="ControlSrc">Te source of ths control</param>
/// <history>
/// [cnurse] 05/26/2008 created
/// </history>
/// -----------------------------------------------------------------------------
private static void AddSkinControl(string ControlKey, string PackageName, string ControlSrc)
{
// check if skin control exists
SkinControlInfo skinControl = SkinControlController.GetSkinControlByKey(ControlKey);
if (skinControl == null)
{
PackageInfo package = new PackageInfo();
package.Name = PackageName;
package.FriendlyName = string.Concat(ControlKey, "SkinObject");
package.PackageType = "SkinObject";
package.Version = new Version(1, 0, 0);
LegacyUtil.ParsePackageName(package);
int PackageId = PackageController.AddPackage(package, false);
skinControl = new SkinControlInfo();
skinControl.PackageID = PackageId;
skinControl.ControlKey = ControlKey;
skinControl.ControlSrc = ControlSrc;
skinControl.SupportsPartialRendering = false;
SkinControlController.SaveSkinControl(skinControl);
}
}
public static void ProcessLegacySkinControls()
{
foreach (SkinControlInfo skinControl in SkinControlController.GetSkinControls().Values)
{
if (skinControl.PackageID == Null.NullInteger)
{
try
{
PackageInfo package = new PackageInfo(new InstallerInfo());
package.Name = skinControl.ControlKey;
package.FriendlyName = skinControl.ControlKey;
package.Description = Null.NullString;
package.Version = new Version(1, 0, 0);
package.PackageType = "SkinObject";
ParsePackageName(package);
SkinControlPackageWriter skinControlWriter = new SkinControlPackageWriter(skinControl, package);
package.Manifest = skinControlWriter.WriteManifest(true);
PackageController.SavePackage(package);
skinControl.PackageID = package.PackageID;
SkinControlController.SaveSkinControl(skinControl);
}
catch (Exception ex)
{
ex.ToString();
}
}
}
}
public WidgetComponentWriter(string basePath, Dictionary<string, InstallFile> files, PackageInfo package)
: base(basePath, files, package)
{
}
public LanguageComponentWriter(Locale language, string basePath, Dictionary<string, InstallFile> files, PackageInfo package)
: base(basePath, files, package)
{
_Language = language;
_PackageType = LanguagePackType.Core;
}
public LibraryPackageWriter(PackageInfo package)
: base(package)
{
BasePath = "DesktopModules\\Libraries";
AssemblyPath = "bin";
}
/// -----------------------------------------------------------------------------
/// <summary>
/// AddModuleDefinition adds a new Core Module Definition to the system
/// </summary>
/// <remarks>
/// This overload allows the caller to determine whether the module has a controller
/// class
/// </remarks>
/// <param name="DesktopModuleName">The Friendly Name of the Module to Add</param>
/// <param name="Description">Description of the Module</param>
/// <param name="ModuleDefinitionName">The Module Definition Name</param>
/// <param name="Premium">A flag representing whether the module is a Premium module</param>
/// <param name="Admin">A flag representing whether the module is an Admin module</param>
/// <returns>The Module Definition Id of the new Module</returns>
/// <history>
/// [cnurse] 10/14/2004 documented
/// [cnurse] 11/11/2004 removed addition of Module Control (now in AddMOduleControl)
/// </history>
/// -----------------------------------------------------------------------------
private static int AddModuleDefinition(string DesktopModuleName, string Description, string ModuleDefinitionName, string BusinessControllerClass, bool IsPortable, bool Premium, bool Admin)
{
// check if desktop module exists
DesktopModuleInfo objDesktopModule = DesktopModuleController.GetDesktopModuleByModuleName(DesktopModuleName, Null.NullInteger);
if (objDesktopModule == null)
{
PackageInfo package = new PackageInfo();
package.Description = Description;
package.FriendlyName = DesktopModuleName;
package.Name = string.Concat("DotNetNuke.", DesktopModuleName);
package.PackageType = "Module";
package.Owner = "DotNetNuke";
package.Organization = "DotNetNuke Corporation";
package.Url = "www.dotnetnuke.com";
package.Email = "*****@*****.**";
if (DesktopModuleName == "Extensions" || DesktopModuleName == "Skin Designer" || DesktopModuleName == "Dashboard")
{
package.IsSystemPackage = true;
}
package.Version = new System.Version(1, 0, 0);
package.PackageID = PackageController.AddPackage(package, false);
string moduleName = DesktopModuleName.Replace(" ", "");
objDesktopModule = new DesktopModuleInfo();
objDesktopModule.DesktopModuleID = Null.NullInteger;
objDesktopModule.PackageID = package.PackageID;
objDesktopModule.FriendlyName = DesktopModuleName;
objDesktopModule.FolderName = "Admin/" + moduleName;
objDesktopModule.ModuleName = moduleName;
objDesktopModule.Description = Description;
objDesktopModule.Version = "01.00.00";
objDesktopModule.BusinessControllerClass = BusinessControllerClass;
objDesktopModule.IsPortable = IsPortable;
objDesktopModule.SupportedFeatures = 0;
if ((IsPortable))
{
objDesktopModule.SupportedFeatures = 1;
}
objDesktopModule.IsPremium = Premium;
objDesktopModule.IsAdmin = Admin;
objDesktopModule.DesktopModuleID = DesktopModuleController.SaveDesktopModule(objDesktopModule, false, false);
if (!Premium)
{
DesktopModuleController.AddDesktopModuleToPortals(objDesktopModule.DesktopModuleID);
}
}
// check if module definition exists
ModuleDefinitionInfo objModuleDefinition = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(ModuleDefinitionName, objDesktopModule.DesktopModuleID);
if (objModuleDefinition == null)
{
objModuleDefinition = new ModuleDefinitionInfo();
objModuleDefinition.ModuleDefID = Null.NullInteger;
objModuleDefinition.DesktopModuleID = objDesktopModule.DesktopModuleID;
objModuleDefinition.FriendlyName = ModuleDefinitionName;
objModuleDefinition.ModuleDefID = ModuleDefinitionController.SaveModuleDefinition(objModuleDefinition, false, false);
}
return objModuleDefinition.ModuleDefID;
}
