/// ----------------------------------------------------------------------------- /// <summary> /// This Constructor creates a new PackageInstaller instance /// </summary> /// <param name="package">A PackageInfo instance</param> /// <history> /// [cnurse] 01/21/2008 created /// </history> /// ----------------------------------------------------------------------------- public PackageInstaller(PackageInfo package) { IsValid = true; DeleteFiles = Null.NullBoolean; Package = package; if (!string.IsNullOrEmpty(package.Manifest)) { //Create an XPathDocument from the Xml var 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) { //Set package installer.Package = package; //Set type installer.Type = package.PackageType; _componentInstallers.Add(0, installer); } } }
public WidgetPackageWriter(PackageInfo package) : base(package) { string company = package.Name; if(company.Contains(".")) { company = company.Substring(0, company.IndexOf(".")); } BasePath = Path.Combine("Resources\\Widgets\\User", company); }
private void CreateCorePackage(bool createZip) { var Package = new PackageInfo(); Package.Name = Globals.CleanFileName(txtFileName.Text); Package.Version = DotNetNukeContext.Current.Application.Version; Package.License = Util.PACKAGE_NoLicense; string fileName = Path.Combine(BasePath, "ResourcePack." + Package.Name); CreatePackage(Package, -2, "", fileName, createZip); }
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("/", "\\"); } }
private void CreateAuthSystemPackage(PackageInfo authPackage, bool createZip) { var Package = new PackageInfo(); Package.Name = authPackage.Name; Package.FriendlyName = authPackage.Name; Package.Version = authPackage.Version; Package.License = Util.PACKAGE_NoLicense; string fileName = Path.Combine(BasePath, "ResourcePack." + Package.Name); AuthenticationInfo authSystem = AuthenticationController.GetAuthenticationServiceByPackageID(authPackage.PackageID); string authPath = authSystem.LoginControlSrc.Substring(0, authSystem.LoginControlSrc.LastIndexOf("/")); CreatePackage(Package, authPackage.PackageID, authPath.Replace("/", "\\"), fileName, createZip); }
private static PackageInfo CreateSkinPackage(SkinPackageInfo skin) { //Create a Package var 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; //See if the Skin is using a Namespace (or is a known skin) ParsePackageName(package); return package; }
/// ----------------------------------------------------------------------------- /// <summary> /// The GetWriter method instantiates the relevant PackageWriter Installer /// </summary> /// <param name="package">The associated PackageInfo instance</param> /// <history> /// [cnurse] 01/31/2008 created /// </history> /// ----------------------------------------------------------------------------- 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: //PackageType is defined in the List var listController = new ListController(); ListEntryInfo entry = listController.GetListEntryInfo("PackageWriter", package.PackageType); if (entry != null && !string.IsNullOrEmpty(entry.Text)) { //The class for the Installer is specified in the Text property writer = (PackageWriterBase) Reflection.CreateObject(entry.Text, "PackageWriter_" + entry.Value); } break; } return writer; }
public SkinControlPackageWriter(XPathNavigator manifestNav, InstallerInfo installer) { SkinControl = new SkinControlInfo(); //Create a Package 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(XPathNavigator manifestNav, InstallerInfo installer) { DesktopModule = new DesktopModuleInfo(); //Create a Package 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 LanguagePackWriter(PackageInfo package) : base(package) { _LanguagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID); if (LanguagePack != null) { _Language = LocaleController.Instance.GetLocale(_LanguagePack.LanguageID); if (LanguagePack.PackageType == LanguagePackType.Core) { BasePath = Null.NullString; } else { //Get the BasePath of the Dependent Package PackageInfo dependendentPackage = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.PackageID == LanguagePack.DependentPackageID); PackageWriterBase dependentPackageWriter = PackageWriterFactory.GetWriter(dependendentPackage); BasePath = dependentPackageWriter.BasePath; } } else { BasePath = Null.NullString; } }
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 = Localization.Localization.SystemLocale; //Create a Package 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; }
public LanguagePackWriter(Locale language, PackageInfo package) : base(package) { _Language = language; BasePath = Null.NullString; }
private void BindLanguageList() { try { var myResponseReader = UpdateService.GetLanguageList(); //empty language list languageList.Items.Clear(); //Loading into XML doc var xmlDoc = new XmlDocument(); xmlDoc.Load(myResponseReader); var languages = xmlDoc.SelectNodes("available/language"); var packages = new List<PackageInfo>(); if (languages != null) { foreach (XmlNode language in languages) { string cultureCode = ""; string version = ""; foreach (XmlNode child in language.ChildNodes) { if (child.Name == "culturecode") { cultureCode = child.InnerText; } if (child.Name == "version") { version = child.InnerText; } } if (!string.IsNullOrEmpty(cultureCode) && !string.IsNullOrEmpty(version) && version.Length == 6) { var myCIintl = new CultureInfo(cultureCode, true); version = version.Insert(4, ".").Insert(2, "."); var package = new PackageInfo { Name = "LanguagePack-" + myCIintl.Name, FriendlyName = myCIintl.NativeName }; package.Name = myCIintl.NativeName; package.Description = cultureCode; Version ver = null; Version.TryParse(version, out ver); package.Version = ver; if (packages.Any(p => p.Name == package.Name)) { var existPackage = packages.First(p => p.Name == package.Name); if (package.Version > existPackage.Version) { packages.Remove(existPackage); packages.Add(package); } } else { packages.Add(package); } } } } foreach (var package in packages) { var li = new ListItem { Value = package.Description, Text = package.Name }; languageList.AddItem(li.Text, li.Value); RadComboBoxItem lastItem = languageList.Items[languageList.Items.Count - 1]; if (DotNetNukeContext.Current.Application.Version.Major != package.Version.Major || DotNetNukeContext.Current.Application.Version.Minor != package.Version.Minor || DotNetNukeContext.Current.Application.Version.Build != package.Version.Build) { lastItem.Attributes.Add("onclick", "javascript:LegacyLangaugePack('" + package.Version + "');"); } } } catch (Exception) { //suppress for now - need to decide what to do when webservice is unreachable //throw; } finally { //ensure there is always an en-us if (languageList.Items.FindItemByValue("en-US") == null) { var myCIintl = new CultureInfo("en-US", true); var li = new ListItem {Value = "en-US", Text = myCIintl.NativeName}; languageList.AddItem(li.Text, li.Value); RadComboBoxItem lastItem = languageList.Items[languageList.Items.Count - 1]; lastItem.Attributes.Add("onclick", "javascript:ClearLegacyLangaugePack();"); languageList.Sort = RadComboBoxSort.Ascending; languageList.Items.Sort(); } var item = languageList.Items.FindItemByValue(_culture); languageList.SelectedIndex = item != null ? item.Index : languageList.Items.FindItemByValue("en-US").Index; languageList.Sort = RadComboBoxSort.Ascending; languageList.Items.Sort(); } }
private void BindGrid(string installPath, DataGrid grid) { var packages = new List<PackageInfo>(); var invalidPackages = new List<string>(); foreach (string file in Directory.GetFiles(installPath)) { if (file.ToLower().EndsWith(".zip") || file.ToLower().EndsWith(".resources")) { Stream inputStream = new FileStream(file, FileMode.Open, FileAccess.Read); var unzip = new ZipInputStream(inputStream); try { ZipEntry entry = unzip.GetNextEntry(); while (entry != null) { if (!entry.IsDirectory) { var fileName = entry.Name; string extension = System.IO.Path.GetExtension(fileName); if (extension.ToLower() == ".dnn" || extension.ToLower() == ".dnn5") { //Manifest var manifestReader = new StreamReader(unzip); var manifest = manifestReader.ReadToEnd(); var package = new PackageInfo(); package.Manifest = manifest; if (!string.IsNullOrEmpty(manifest)) { var doc = new XPathDocument(new StringReader(manifest)); XPathNavigator rootNav = doc.CreateNavigator().SelectSingleNode("dotnetnuke"); string packageType = String.Empty; if (rootNav.Name == "dotnetnuke") { packageType = XmlUtils.GetAttributeValue(rootNav, "type"); } else if (rootNav.Name.ToLower() == "languagepack") { packageType = "LanguagePack"; } XPathNavigator nav = null; switch (packageType.ToLower()) { case "package": nav = rootNav.SelectSingleNode("packages/package"); break; case "module": case "languagepack": case "skinobject": nav = Installer.ConvertLegacyNavigator(rootNav, new InstallerInfo()).SelectSingleNode("packages/package"); break; } if (nav != null) { package.Name = XmlUtils.GetAttributeValue(nav, "name"); package.PackageType = XmlUtils.GetAttributeValue(nav, "type"); package.IsSystemPackage = XmlUtils.GetAttributeValueAsBoolean(nav, "isSystem", false); package.Version = new Version(XmlUtils.GetAttributeValue(nav, "version")); package.FriendlyName = XmlUtils.GetNodeValue(nav, "friendlyName"); if (String.IsNullOrEmpty(package.FriendlyName)) { package.FriendlyName = package.Name; } package.Description = XmlUtils.GetNodeValue(nav, "description"); package.FileName = file.Replace(installPath + "\\", ""); XPathNavigator foldernameNav = null; switch (package.PackageType) { case "Module": case "Auth_System": foldernameNav = nav.SelectSingleNode("components/component/files"); if (foldernameNav != null) package.FolderName = Util.ReadElement(foldernameNav, "basePath").Replace('\\', '/'); break; case "Container": foldernameNav = nav.SelectSingleNode("components/component/containerFiles"); if (foldernameNav != null) package.FolderName = Globals.glbContainersPath + Util.ReadElement(foldernameNav, "containerName").Replace('\\', '/'); break; case "Skin": foldernameNav = nav.SelectSingleNode("components/component/skinFiles"); if (foldernameNav != null) package.FolderName = Globals.glbSkinsPath + Util.ReadElement(foldernameNav, "skinName").Replace('\\', '/'); break; default: break; } XPathNavigator iconFileNav = nav.SelectSingleNode("iconFile"); if (package.FolderName != string.Empty && iconFileNav != null) { if ((iconFileNav.Value != string.Empty) && (package.PackageType == "Module" || package.PackageType == "Auth_System" || package.PackageType == "Container" || package.PackageType == "Skin")) { package.IconFile = package.FolderName + "/" + iconFileNav.Value; package.IconFile = (!package.IconFile.StartsWith("~/")) ? "~/" + package.IconFile : package.IconFile; } } packages.Add(package); } } break; } } entry = unzip.GetNextEntry(); } } catch (Exception) { invalidPackages.Add(file); } finally { unzip.Close(); unzip.Dispose(); } } } if (invalidPackages.Count > 0) { var pkgErrorsMsg = invalidPackages.Aggregate(string.Empty, (current, pkg) => current + (pkg + "<br />")); UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("PackageErrors.Text", LocalResourceFile) + pkgErrorsMsg, ModuleMessage.ModuleMessageType.RedError); } grid.DataSource = packages; grid.DataBind(); }
/// ----------------------------------------------------------------------------- /// <summary> /// This routine binds the package to the Property Editor /// </summary> /// <history> /// [cnurse] 07/26/2007 Created /// </history> /// ----------------------------------------------------------------------------- private void BindPackage() { CreateInstaller(); if (Installer.IsValid) { if (_Installer.Packages.Count > 0) { _Package = _Installer.Packages[0].Package; } //Bind Package Info packageForm.DataSource = _Package; packageForm.DataBind(); //Bind License Info licenseForm.DataSource = _Package; licenseForm.DataBind(); //Bind ReleaseNotes Info releaseNotesForm.DataSource = _Package; releaseNotesForm.DataBind(); } else { //Error reading Manifest switch (wizInstall.ActiveStepIndex) { case 0: lblLoadMessage.Text = Localization.GetString("InstallError", LocalResourceFile); phLoadLogs.Controls.Add(Installer.InstallerInfo.Log.GetLogsTable()); break; case 3: lblAcceptMessage.Text = Localization.GetString("InstallError", LocalResourceFile); lblAcceptMessage.Visible = true; phAcceptLogs.Controls.Add(Installer.InstallerInfo.Log.GetLogsTable()); break; } } }
public static void ProcessLegacySkinControls() { foreach (SkinControlInfo skinControl in SkinControlController.GetSkinControls().Values) { if (skinControl.PackageID == Null.NullInteger) { try { //SkinControl is not affiliated with a Package var 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"; //See if the SkinControl is using a "Namespace" for its name ParsePackageName(package); var skinControlWriter = new SkinControlPackageWriter(skinControl, package); package.Manifest = skinControlWriter.WriteManifest(true); //Save Package PackageController.Instance.SaveExtensionPackage(package); //Update SkinControl with new PackageID skinControl.PackageID = package.PackageID; //Save SkinControl SkinControlController.SaveSkinControl(skinControl); } catch (Exception exc) { Logger.Error(exc); } } } }
public static void ParsePackageName(PackageInfo package) { ParsePackageName(package, "."); if (string.IsNullOrEmpty(package.Owner)) { ParsePackageName(package, "\\"); } if (string.IsNullOrEmpty(package.Owner)) { ParsePackageName(package, "_"); } if (package.PackageType == "Module" && AdminModules.Contains(package.Name + ",") || package.PackageType == "Module" && CoreModules.Contains(package.Name + ",") || (package.PackageType == "Container" || package.PackageType == "Skin") && KnownSkins.Contains(package.Name + ",") || package.PackageType == "SkinObject" && KnownSkinObjects.Contains(package.Name + ",")) { if (string.IsNullOrEmpty(package.Owner)) { package.Owner = "DotNetNuke"; package.Name = "DotNetNuke." + package.Name; switch (package.PackageType) { case "Skin": package.Name += ".Skin"; package.FriendlyName += " Skin"; break; case "Container": package.Name += ".Container"; package.FriendlyName += " Container"; break; case "SkinObject": package.Name += "SkinObject"; package.FriendlyName += " SkinObject"; break; } } } if (package.Owner == "DotNetNuke" || package.Owner == "DNN") { package.License = Localization.Localization.GetString("License", Localization.Localization.GlobalResourceFile); package.Organization = "DNN Corp."; package.Url = "http://www.dnnsoftware.com"; package.Email = "*****@*****.**"; package.ReleaseNotes = "There are no release notes for this version."; } else { package.License = Util.PACKAGE_NoLicense; } }
public static void ProcessLegacyLanguages() { string filePath = Globals.ApplicationMapPath + Localization.Localization.SupportedLocalesFile.Substring(1).Replace("/", "\\"); if (File.Exists(filePath)) { var doc = new XPathDocument(filePath); //Check for Browser and Url settings XPathNavigator browserNav = doc.CreateNavigator().SelectSingleNode("root/browserDetection"); if (browserNav != null) { HostController.Instance.Update("EnableBrowserLanguage", Util.ReadAttribute(browserNav, "enabled", false, null, Null.NullString, "true")); } XPathNavigator urlNav = doc.CreateNavigator().SelectSingleNode("root/languageInUrl"); if (urlNav != null) { HostController.Instance.Update("EnableUrlLanguage", Util.ReadAttribute(urlNav, "enabled", false, null, Null.NullString, "true")); } //Process each language foreach (XPathNavigator nav in doc.CreateNavigator().Select("root/language")) { if (nav.NodeType != XPathNodeType.Comment) { var language = new Locale(); language.Text = Util.ReadAttribute(nav, "name"); language.Code = Util.ReadAttribute(nav, "key"); language.Fallback = Util.ReadAttribute(nav, "fallback"); //Save Language Localization.Localization.SaveLanguage(language); if (language.Code != Localization.Localization.SystemLocale) { //Create a Package var package = new PackageInfo(new InstallerInfo()) { Name = language.Text, FriendlyName = language.Text, Description = Null.NullString, Version = new Version(1, 0, 0), PackageType = "CoreLanguagePack", License = Util.PACKAGE_NoLicense }; //Create a LanguagePackWriter var packageWriter = new LanguagePackWriter(language, package); //Save the manifest package.Manifest = packageWriter.WriteManifest(true); //Save Package PackageController.Instance.SaveExtensionPackage(package); var languagePack = new LanguagePackInfo { LanguageID = language.LanguageId, PackageID = package.PackageID, DependentPackageID = -2 }; LanguagePackController.SaveLanguagePack(languagePack); } } } } //Process Portal Locales files foreach (PortalInfo portal in PortalController.Instance.GetPortals()) { int portalID = portal.PortalID; filePath = string.Format(Globals.ApplicationMapPath + Localization.Localization.ApplicationResourceDirectory.Substring(1).Replace("/", "\\") + "\\Locales.Portal-{0}.xml", portalID); if (File.Exists(filePath)) { var doc = new XPathDocument(filePath); //Check for Browser and Url settings XPathNavigator browserNav = doc.CreateNavigator().SelectSingleNode("locales/browserDetection"); if (browserNav != null) { PortalController.UpdatePortalSetting(portalID, "EnableBrowserLanguage", Util.ReadAttribute(browserNav, "enabled", false, null, Null.NullString, "true")); } XPathNavigator urlNav = doc.CreateNavigator().SelectSingleNode("locales/languageInUrl"); if (urlNav != null) { PortalController.UpdatePortalSetting(portalID, "EnableUrlLanguage", Util.ReadAttribute(urlNav, "enabled", false, null, Null.NullString, "true")); } foreach (Locale installedLanguage in LocaleController.Instance.GetLocales(Null.NullInteger).Values) { string code = installedLanguage.Code; bool bFound = false; //Check if this language is "inactive" foreach (XPathNavigator inactiveNav in doc.CreateNavigator().Select("locales/inactive/locale")) { if (inactiveNav.Value == code) { bFound = true; break; } } if (!bFound) { //Language is enabled - add to portal Localization.Localization.AddLanguageToPortal(portalID, installedLanguage.LanguageId, false); } } } else { foreach (Locale installedLanguage in LocaleController.Instance.GetLocales(Null.NullInteger).Values) { //Language is enabled - add to portal Localization.Localization.AddLanguageToPortal(portalID, installedLanguage.LanguageId, false); } } } }
/// <summary> /// </summary> /// <remarks> /// </remarks> /// <history> /// </history> private bool CreateModuleDefinition() { try { if (PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.Name == GetClassName()) == null) { var controlName = Null.NullString; //Create module folder CreateModuleFolder(); //Create module control controlName = CreateModuleControl(); if (controlName != "") { //Create package var objPackage = new PackageInfo(); objPackage.Name = GetClassName(); objPackage.FriendlyName = txtModule.Text; objPackage.Description = txtDescription.Text; objPackage.Version = new Version(1, 0, 0); objPackage.PackageType = "Module"; objPackage.License = ""; objPackage.Owner = txtOwner.Text; objPackage.Organization = txtOwner.Text; objPackage.FolderName = "DesktopModules/" + GetFolderName(); objPackage.License = "The license for this package is not currently included within the installation file, please check with the vendor for full license details."; objPackage.ReleaseNotes = "This package has no Release Notes."; PackageController.Instance.SaveExtensionPackage(objPackage); //Create desktopmodule var objDesktopModules = new DesktopModuleController(); var objDesktopModule = new DesktopModuleInfo(); objDesktopModule.DesktopModuleID = Null.NullInteger; objDesktopModule.ModuleName = GetClassName(); objDesktopModule.FolderName = GetFolderName(); objDesktopModule.FriendlyName = txtModule.Text; objDesktopModule.Description = txtDescription.Text; objDesktopModule.IsPremium = false; objDesktopModule.IsAdmin = false; objDesktopModule.Version = "01.00.00"; objDesktopModule.BusinessControllerClass = ""; objDesktopModule.CompatibleVersions = ""; objDesktopModule.Dependencies = ""; objDesktopModule.Permissions = ""; objDesktopModule.PackageID = objPackage.PackageID; objDesktopModule.DesktopModuleID = objDesktopModules.AddDesktopModule(objDesktopModule); objDesktopModule = objDesktopModules.GetDesktopModule(objDesktopModule.DesktopModuleID); //Add OwnerName to the DesktopModule taxonomy and associate it with this module var vocabularyId = -1; var termId = -1; var objTermController = DotNetNuke.Entities.Content.Common.Util.GetTermController(); var objTerms = objTermController.GetTermsByVocabulary("Module_Categories"); foreach (Term term in objTerms) { vocabularyId = term.VocabularyId; if (term.Name == txtOwner.Text) { termId = term.TermId; } } if (termId == -1) { termId = objTermController.AddTerm(new Term(vocabularyId) { Name = txtOwner.Text }); } var objTerm = objTermController.GetTerm(termId); var objContentController = DotNetNuke.Entities.Content.Common.Util.GetContentController(); var objContent = objContentController.GetContentItem(objDesktopModule.ContentItemId); objTermController.AddTermToContent(objTerm, objContent); //Add desktopmodule to all portals DesktopModuleController.AddDesktopModuleToPortals(objDesktopModule.DesktopModuleID); //Create module definition var objModuleDefinition = new ModuleDefinitionInfo(); objModuleDefinition.ModuleDefID = Null.NullInteger; objModuleDefinition.DesktopModuleID = objDesktopModule.DesktopModuleID; // need core enhancement to have a unique DefinitionName objModuleDefinition.FriendlyName = GetClassName(); //objModuleDefinition.FriendlyName = txtModule.Text; //objModuleDefinition.DefinitionName = GetClassName(); objModuleDefinition.DefaultCacheTime = 0; objModuleDefinition.ModuleDefID = ModuleDefinitionController.SaveModuleDefinition(objModuleDefinition, false, true); //Create modulecontrol var objModuleControl = new ModuleControlInfo(); objModuleControl.ModuleControlID = Null.NullInteger; objModuleControl.ModuleDefID = objModuleDefinition.ModuleDefID; objModuleControl.ControlKey = ""; objModuleControl.ControlSrc = "DesktopModules/" + GetFolderName() + "/" + controlName; objModuleControl.ControlTitle = ""; objModuleControl.ControlType = SecurityAccessLevel.View; objModuleControl.HelpURL = ""; objModuleControl.IconFile = ""; objModuleControl.ViewOrder = 0; objModuleControl.SupportsPartialRendering = false; objModuleControl.SupportsPopUps = false; ModuleControlController.AddModuleControl(objModuleControl); //Update current module to reference new moduledefinition var objModules = new ModuleController(); var objModule = objModules.GetModule(ModuleId, TabId, false); objModule.ModuleDefID = objModuleDefinition.ModuleDefID; objModule.ModuleTitle = txtModule.Text; //HACK - need core enhancement to be able to update ModuleDefID DotNetNuke.Data.DataProvider.Instance().ExecuteSQL("Update dbo.Modules set ModuleDefID = " + objModule.ModuleDefID.ToString() + " where ModuleID = " + ModuleId.ToString()); objModules.UpdateModule(objModule); return true; } else { DotNetNuke.UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("TemplateProblem.ErrorMessage", LocalResourceFile), ModuleMessage.ModuleMessageType.YellowWarning); return false; } } else { DotNetNuke.UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("AlreadyExists.ErrorMessage", LocalResourceFile), ModuleMessage.ModuleMessageType.YellowWarning); return false; } } catch (Exception exc) { Exceptions.LogException(exc); DotNetNuke.UI.Skins.Skin.AddModuleMessage(this, exc.ToString(), ModuleMessage.ModuleMessageType.RedError); return false; } }
private static void ParsePackageName(PackageInfo package, string separator) { //See if the Module is using a "Namespace" for its name int ownerIndex = package.Name.IndexOf(separator); if (ownerIndex > 0) { package.Owner = package.Name.Substring(0, ownerIndex); } }
/// ----------------------------------------------------------------------------- /// <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="businessControllerClass">Business Control Class.</param> /// <param name="isPortable">Whether the module is enable for portals.</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) { DnnInstallLogger.InstallLogInfo(Localization.Localization.GetString("LogStart", Localization.Localization.GlobalResourceFile) + "AddModuleDefinition:" + desktopModuleName); // check if desktop module exists var desktopModule = DesktopModuleController.GetDesktopModuleByModuleName(desktopModuleName, Null.NullInteger); if (desktopModule == null) { var package = new PackageInfo { Description = description, FriendlyName = desktopModuleName, Name = string.Concat("DotNetNuke.", desktopModuleName), PackageType = "Module", Owner = "DNN", Organization = "DNN Corp.", Url = "http://www.dnnsoftware.com", Email = "*****@*****.**" }; if (desktopModuleName == "Extensions" || desktopModuleName == "Skin Designer" || desktopModuleName == "Dashboard") { package.IsSystemPackage = true; } package.Version = new Version(1, 0, 0); PackageController.Instance.SaveExtensionPackage(package); string moduleName = desktopModuleName.Replace(" ", ""); desktopModule = new DesktopModuleInfo { DesktopModuleID = Null.NullInteger, PackageID = package.PackageID, FriendlyName = desktopModuleName, FolderName = "Admin/" + moduleName, ModuleName = moduleName, Description = description, Version = "01.00.00", BusinessControllerClass = businessControllerClass, IsPortable = isPortable, SupportedFeatures = 0 }; if ((isPortable)) { desktopModule.SupportedFeatures = 1; } desktopModule.IsPremium = premium; desktopModule.IsAdmin = admin; desktopModule.DesktopModuleID = DesktopModuleController.SaveDesktopModule(desktopModule, false, false); if (!premium) { DesktopModuleController.AddDesktopModuleToPortals(desktopModule.DesktopModuleID); } } // check if module definition exists var moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(moduleDefinitionName, desktopModule.DesktopModuleID); if (moduleDefinition == null) { moduleDefinition = new ModuleDefinitionInfo { ModuleDefID = Null.NullInteger, DesktopModuleID = desktopModule.DesktopModuleID, FriendlyName = moduleDefinitionName }; moduleDefinition.ModuleDefID = ModuleDefinitionController.SaveModuleDefinition(moduleDefinition, false, false); } return moduleDefinition.ModuleDefID; }
/// ----------------------------------------------------------------------------- /// <summary> /// The ReadManifest method reads the manifest file and parses it into components. /// </summary> /// <history> /// [cnurse] 07/24/2007 created /// </history> /// ----------------------------------------------------------------------------- public override void ReadManifest(XPathNavigator manifestNav) { //Get Name Property Package.Name = Util.ReadAttribute(manifestNav, "name", Log, Util.EXCEPTION_NameMissing); //Get Type Package.PackageType = Util.ReadAttribute(manifestNav, "type", Log, Util.EXCEPTION_TypeMissing); //If Skin or Container then set PortalID if (Package.PackageType == "Skin" || Package.PackageType == "Container") { Package.PortalID = Package.InstallerInfo.PortalID; } CheckSecurity(); if (!IsValid) { return; } //Attempt to get the Package from the Data Store (see if its installed) _installedPackage = PackageController.GetPackageByName(Package.PortalID, Package.Name); //Get IsSystem Package.IsSystemPackage = bool.Parse(Util.ReadAttribute(manifestNav, "isSystem", false, Log, "", bool.FalseString)); //Get Version 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 foldernameNav = null; Package.FolderName = String.Empty; switch (Package.PackageType) { case "Module": //In Dynamics moduels, a component:type=File can have a basePath pointing to the App_Conde folder. This is not a correct FolderName //To ensure that FolderName is DesktopModules... var folderNameValue = getSpecificFolderName(manifestNav, "components/component/files", "basePath", "DesktopModules"); if (!String.IsNullOrEmpty(folderNameValue)) Package.FolderName = folderNameValue.Replace('\\', '/'); break; case "Auth_System": foldernameNav = manifestNav.SelectSingleNode("components/component/files"); if (foldernameNav != null) Package.FolderName = Util.ReadElement(foldernameNav, "basePath").Replace('\\', '/'); break; case "Container": foldernameNav = manifestNav.SelectSingleNode("components/component/containerFiles"); if (foldernameNav != null) Package.FolderName = Globals.glbContainersPath + Util.ReadElement(foldernameNav, "containerName").Replace('\\', '/'); break; case "Skin": foldernameNav = manifestNav.SelectSingleNode("components/component/skinFiles"); if (foldernameNav != null) Package.FolderName = Globals.glbSkinsPath + Util.ReadElement(foldernameNav, "skinName").Replace('\\', '/'); break; default: break; } //Get Icon XPathNavigator iconFileNav = manifestNav.SelectSingleNode("iconFile"); if (iconFileNav != null) { if (iconFileNav.Value != string.Empty) { if (iconFileNav.Value.StartsWith("~/")) { Package.IconFile = iconFileNav.Value; } else { Package.IconFile = (String.IsNullOrEmpty(Package.FolderName) ? "" : Package.FolderName + "/") + iconFileNav.Value; Package.IconFile = (!Package.IconFile.StartsWith("~/")) ? "~/" + Package.IconFile : Package.IconFile; } } } //Get Author 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"); } //Get License XPathNavigator licenseNav = manifestNav.SelectSingleNode("license"); if (licenseNav != null) { string licenseSrc = Util.ReadAttribute(licenseNav, "src"); if (string.IsNullOrEmpty(licenseSrc)) { //Load from element Package.License = licenseNav.Value; } else { Package.License = ReadTextFromFile(licenseSrc); } } if (string.IsNullOrEmpty(Package.License)) { //Legacy Packages have no license Package.License = Util.PACKAGE_NoLicense; } //Get Release Notes XPathNavigator relNotesNav = manifestNav.SelectSingleNode("releaseNotes"); if (relNotesNav != null) { string relNotesSrc = Util.ReadAttribute(relNotesNav, "src"); if (string.IsNullOrEmpty(relNotesSrc)) { //Load from element Package.ReleaseNotes = relNotesNav.Value; } else { Package.ReleaseNotes = ReadTextFromFile(relNotesSrc); } } if (string.IsNullOrEmpty(Package.ReleaseNotes)) { //Legacy Packages have no Release Notes Package.ReleaseNotes = Util.PACKAGE_NoReleaseNotes; } //Parse the Dependencies IDependency dependency = null; foreach (XPathNavigator dependencyNav in manifestNav.CreateNavigator().Select("dependencies/dependency")) { dependency = DependencyFactory.GetDependency(dependencyNav); if (!dependency.IsValid) { Log.AddFailure(dependency.ErrorMessage); return; } } //Read Components ReadComponents(manifestNav); }
/// ----------------------------------------------------------------------------- /// <summary> /// This Constructor creates a new PackageInstaller instance /// </summary> /// <param name="info">An InstallerInfo instance</param> /// <param name="packageManifest">The manifest as a string</param> /// <history> /// [cnurse] 01/16/2008 created /// </history> /// ----------------------------------------------------------------------------- public PackageInstaller(string packageManifest, InstallerInfo info) { IsValid = true; DeleteFiles = Null.NullBoolean; Package = new PackageInfo(info); Package.Manifest = packageManifest; if (!string.IsNullOrEmpty(packageManifest)) { //Create an XPathDocument from the Xml var doc = new XPathDocument(new StringReader(packageManifest)); XPathNavigator nav = doc.CreateNavigator().SelectSingleNode("package"); ReadManifest(nav); } }
/// ----------------------------------------------------------------------------- /// <summary> /// This Constructor creates a new Installer instance from a PackageInfo object /// </summary> /// <param name="package">The PackageInfo instance</param> /// <param name="physicalSitePath">The physical path to the root of the site</param> /// ----------------------------------------------------------------------------- public Installer(PackageInfo package, string physicalSitePath) { Packages = new SortedList<int, PackageInstaller>(); InstallerInfo = new InstallerInfo(package, physicalSitePath); Packages.Add(Packages.Count, new PackageInstaller(package)); }
public static void ProcessLegacyModule(DesktopModuleInfo desktopModule) { //Get the Module folder string moduleFolder = Path.Combine(Globals.ApplicationMapPath, Path.Combine("DesktopModules", desktopModule.FolderName)); //Find legacy manifest XPathNavigator rootNav = null; try { string hostModules = "Portals, SQL, HostSettings, Scheduler, SearchAdmin, Lists, SkinDesigner, Extensions"; string[] files = Directory.GetFiles(moduleFolder, "*.dnn.config"); if (files.Length > 0) { //Create an XPathDocument from the Xml var doc = new XPathDocument(new FileStream(files[0], FileMode.Open, FileAccess.Read)); rootNav = doc.CreateNavigator().SelectSingleNode("dotnetnuke"); } //Module is not affiliated with a Package var package = new PackageInfo(new InstallerInfo()); package.Name = desktopModule.ModuleName; package.FriendlyName = desktopModule.FriendlyName; package.Description = desktopModule.Description; package.Version = new Version(1, 0, 0); if (!string.IsNullOrEmpty(desktopModule.Version)) { package.Version = new Version(desktopModule.Version); } if (hostModules.Contains(desktopModule.ModuleName)) { //Host Module so make this a system package package.IsSystemPackage = true; desktopModule.IsAdmin = true; } else { desktopModule.IsAdmin = false; } package.PackageType = "Module"; //See if the Module is using a "Namespace" for its name ParsePackageName(package); if (files.Length > 0) { var modulewriter = new ModulePackageWriter(desktopModule, rootNav, package); package.Manifest = modulewriter.WriteManifest(true); } else { package.Manifest = ""; //module has no manifest } //Save Package PackageController.Instance.SaveExtensionPackage(package); //Update Desktop Module with new PackageID desktopModule.PackageID = package.PackageID; //Save DesktopModule DesktopModuleController.SaveDesktopModule(desktopModule, false, false); } catch (Exception exc) { Logger.Error(exc); } }
private static void UpgradeToVersion513() { //Ensure that default language is present (not neccessarily enabled) var defaultLanguage = LocaleController.Instance.GetLocale("en-US") ?? new Locale(); defaultLanguage.Code = "en-US"; defaultLanguage.Text = "English (United States)"; Localization.Localization.SaveLanguage(defaultLanguage); //Ensure that there is a Default Authorization System var package = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.Name == "DefaultAuthentication"); if (package == null) { package = new PackageInfo { Name = "DefaultAuthentication", FriendlyName = "Default Authentication", Description = "The Default UserName/Password Authentication System for DotNetNuke.", PackageType = "Auth_System", Version = new Version(1, 0, 0), Owner = "DNN", License = Localization.Localization.GetString("License", Localization.Localization.GlobalResourceFile), Organization = "DNN Corp.", Url = "http://www.dnnsoftware.com", Email = "*****@*****.**", ReleaseNotes = "There are no release notes for this version.", IsSystemPackage = true }; PackageController.Instance.SaveExtensionPackage(package); //Add Authentication System var authSystem = AuthenticationController.GetAuthenticationServiceByType("DNN") ?? new 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) { AuthenticationController.AddAuthentication(authSystem); } else { AuthenticationController.UpdateAuthentication(authSystem); } } }
private void BindGrid(string type, DataGrid grid, HtmlGenericControl noItemsControl) { var installPath = Globals.ApplicationMapPath + "\\Install\\" + type; var packages = new List<PackageInfo>(); var invalidPackages = new List<string>(); foreach (string file in Directory.GetFiles(installPath)) { if (file.ToLower().EndsWith(".zip") || file.ToLower().EndsWith(".resources")) { Stream inputStream = new FileStream(file, FileMode.Open, FileAccess.Read); var unzip = new ZipInputStream(inputStream); try { ZipEntry entry = unzip.GetNextEntry(); while (entry != null) { if (!entry.IsDirectory) { var fileName = entry.Name; string extension = Path.GetExtension(fileName); if (extension.ToLower() == ".dnn" || extension.ToLower() == ".dnn5") { //Manifest var manifestReader = new StreamReader(unzip); var manifest = manifestReader.ReadToEnd(); var package = new PackageInfo(); package.Manifest = manifest; if (!string.IsNullOrEmpty(manifest)) { var doc = new XPathDocument(new StringReader(manifest)); XPathNavigator rootNav = doc.CreateNavigator().SelectSingleNode("dotnetnuke"); string packageType = String.Empty; if (rootNav.Name == "dotnetnuke") { packageType = XmlUtils.GetAttributeValue(rootNav, "type"); } else if (rootNav.Name.ToLower() == "languagepack") { packageType = "LanguagePack"; } XPathNavigator nav = null; switch (packageType.ToLower()) { case "package": nav = rootNav.SelectSingleNode("packages/package"); break; case "languagepack": //nav = Installer.ConvertLegacyNavigator(rootNav, new InstallerInfo()).SelectSingleNode("packages/package"); break; } if (nav != null) { package.Name = XmlUtils.GetAttributeValue(nav, "name"); package.PackageType = XmlUtils.GetAttributeValue(nav, "type"); package.IsSystemPackage = XmlUtils.GetAttributeValueAsBoolean(nav, "isSystem", false); package.Version = new Version(XmlUtils.GetAttributeValue(nav, "version")); package.FriendlyName = XmlUtils.GetNodeValue(nav, "friendlyName"); if (String.IsNullOrEmpty(package.FriendlyName)) { package.FriendlyName = package.Name; } package.Description = XmlUtils.GetNodeValue(nav, "description"); package.FileName = file.Replace(installPath + "\\", ""); packages.Add(package); } } break; } } entry = unzip.GetNextEntry(); } } catch (Exception) { invalidPackages.Add(file); } finally { unzip.Close(); unzip.Dispose(); } } } if (invalidPackages.Count > 0) { var pkgErrorsMsg = invalidPackages.Aggregate(string.Empty, (current, pkg) => current + (pkg + "<br />")); Skin.AddModuleMessage(this, Localization.GetString("PackageErrors.Text", LocalResourceFile) + pkgErrorsMsg, ModuleMessage.ModuleMessageType.RedError); } if (packages.Count == 0) { noItemsControl.Visible = true; grid.Visible = false; } else { noItemsControl.Visible = false; grid.DataSource = packages; grid.DataBind(); } }
/// ----------------------------------------------------------------------------- /// <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="packageName">Package Name.</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) { DnnInstallLogger.InstallLogInfo(Localization.Localization.GetString("LogStart", Localization.Localization.GlobalResourceFile) + "AddSkinControl:" + controlKey); // check if skin control exists SkinControlInfo skinControl = SkinControlController.GetSkinControlByKey(controlKey); if (skinControl == null) { var package = new PackageInfo { Name = packageName, FriendlyName = string.Concat(controlKey, "SkinObject"), PackageType = "SkinObject", Version = new Version(1, 0, 0) }; LegacyUtil.ParsePackageName(package); PackageController.Instance.SaveExtensionPackage(package); skinControl = new SkinControlInfo { PackageID = package.PackageID, ControlKey = controlKey, ControlSrc = controlSrc, SupportsPartialRendering = false }; SkinControlController.SaveSkinControl(skinControl); } }
public WidgetComponentWriter(string basePath, Dictionary<string, InstallFile> files, PackageInfo package) : base(basePath, files, package) { }