/// <summary> /// BindData fetches the data from the database and updates the controls /// </summary> /// <history> /// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support /// and localisation /// </history> public void BindData() { if (!Page.IsPostBack) { GetFeatures(); } if (Convert.ToString(Globals.HostSettings["CheckUpgrade"]) == "N") { lblUpdate.Visible = false; grdDefinitions.Columns[4].HeaderText = ""; } // Get the portal's defs from the database DesktopModuleController objDesktopModules = new DesktopModuleController(); ArrayList arr = objDesktopModules.GetDesktopModules(); DesktopModuleInfo objDesktopModule = new DesktopModuleInfo(); objDesktopModule.DesktopModuleID = - 2; objDesktopModule.FriendlyName = Localization.GetString( "SkinObjects" ); objDesktopModule.Description = Localization.GetString( "SkinObjectsDescription" ); objDesktopModule.IsPremium = false; arr.Insert( 0, objDesktopModule ); //Localize Grid Localization.LocalizeDataGrid(ref grdDefinitions, this.LocalResourceFile ); grdDefinitions.DataSource = arr; grdDefinitions.DataBind(); }
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); }
/// ----------------------------------------------------------------------------- /// <summary> /// DeleteDesktopModule deletes a Desktop Module /// </summary> /// <param name="moduleName">The Name of the Desktop Module to delete</param> /// ----------------------------------------------------------------------------- public static void DeleteDesktopModule(string moduleName) { DesktopModuleInfo desktopModule = GetDesktopModuleByModuleName(moduleName, Null.NullInteger); if (desktopModule != null) { var controller = new DesktopModuleController(); controller.DeleteDesktopModule(desktopModule.DesktopModuleID); //Delete the Package PackageController.Instance.DeleteExtensionPackage(PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.PackageID == desktopModule.PackageID)); } }
/// ----------------------------------------------------------------------------- /// <summary> /// GetDesktopModuleByModuleName gets a Desktop Module by its Name /// </summary> /// <remarks>This method uses the cached Dictionary of DesktopModules. It first checks /// if the DesktopModule is in the cache. If it is not in the cache it then makes a call /// to the Dataprovider.</remarks> /// <param name="moduleName">The name of the Desktop Module to get</param> /// <param name="portalID">The ID of the portal</param> /// ----------------------------------------------------------------------------- public static DesktopModuleInfo GetDesktopModuleByModuleName(string moduleName, int portalID) { DesktopModuleInfo desktopModuleByModuleName = (from kvp in GetDesktopModulesInternal(portalID) where kvp.Value.ModuleName == moduleName select kvp.Value).FirstOrDefault(); if (desktopModuleByModuleName == null) { Logger.WarnFormat("Unable to find module by name. Name:{0} portalId:{1}", moduleName, portalID); } return(desktopModuleByModuleName); }
/// ----------------------------------------------------------------------------- /// <summary> /// GetDesktopModuleByPackageID gets a Desktop Module by its Package ID /// </summary> /// <param name="packageID">The ID of the Package</param> /// ----------------------------------------------------------------------------- public static DesktopModuleInfo GetDesktopModuleByPackageID(int packageID) { DesktopModuleInfo desktopModuleByPackageID = (from kvp in GetDesktopModulesInternal(Null.NullInteger) where kvp.Value.PackageID == packageID select kvp.Value) .FirstOrDefault(); if (desktopModuleByPackageID == null) { Logger.WarnFormat("Unable to find module by package ID. ID:{0}", packageID); } return(desktopModuleByPackageID); }
public static int AddDesktopModuleToPortal(int portalID, DesktopModuleInfo desktopModule, DesktopModulePermissionCollection permissions, bool clearCache) { int portalDesktopModuleID = AddDesktopModuleToPortal(portalID, desktopModule.DesktopModuleID, false, clearCache); if (portalDesktopModuleID > Null.NullInteger) { DesktopModulePermissionController.DeleteDesktopModulePermissionsByPortalDesktopModuleID(portalDesktopModuleID); foreach (DesktopModulePermissionInfo permission in permissions) { permission.PortalDesktopModuleID = portalDesktopModuleID; DesktopModulePermissionController.AddDesktopModulePermission(permission); } } return(portalDesktopModuleID); }
private static void CreateContentItem(DesktopModuleInfo desktopModule) { IContentTypeController typeController = new ContentTypeController(); ContentType contentType = ContentType.DesktopModule; if (contentType == null) { contentType = new ContentType { ContentType = "DesktopModule" }; contentType.ContentTypeId = typeController.AddContentType(contentType); } IContentController contentController = Util.GetContentController(); desktopModule.Content = desktopModule.FriendlyName; desktopModule.Indexed = false; desktopModule.ContentTypeId = contentType.ContentTypeId; desktopModule.ContentItemId = contentController.AddContentItem(desktopModule); }
internal static void AddDesktopModulePageToPortal(DesktopModuleInfo desktopModule, string pageName, int portalId, ref bool createdNewPage, ref bool addedNewModule) { var tabPath = string.Format("//{0}//{1}", portalId == Null.NullInteger ? "Host" : "Admin", pageName); var tabId = TabController.GetTabByTabPath(portalId, tabPath, Null.NullString); TabInfo existTab = TabController.Instance.GetTab(tabId, portalId); if (existTab == null) { if (portalId == Null.NullInteger) { existTab = Upgrade.AddHostPage( pageName, desktopModule.Page.Description, desktopModule.Page.Icon, desktopModule.Page.LargeIcon, true); } else { existTab = Upgrade.AddAdminPage( PortalController.Instance.GetPortal(portalId), pageName, desktopModule.Page.Description, desktopModule.Page.Icon, desktopModule.Page.LargeIcon, true); } createdNewPage = true; } if (existTab != null) { if (desktopModule.Page.IsCommon) { TabController.Instance.UpdateTabSetting(existTab.TabID, "ControlBar_CommonTab", "Y"); } AddDesktopModuleToPage(desktopModule, existTab, ref addedNewModule); } }
public void UpdateModuleInterfaces(ref DesktopModuleInfo desktopModuleInfo, string sender, bool forceAppRestart) { var oAppStartMessage = new EventMessage { Sender = sender, Priority = MessagePriority.High, ExpirationDate = DateTime.Now.AddYears(-1), SentDate = DateTime.Now, Body = "", ProcessorType = "DotNetNuke.Entities.Modules.EventMessageProcessor, DotNetNuke", ProcessorCommand = "UpdateSupportedFeatures" }; oAppStartMessage.Attributes.Add("BusinessControllerClass", desktopModuleInfo.BusinessControllerClass); oAppStartMessage.Attributes.Add("DesktopModuleId", desktopModuleInfo.DesktopModuleID.ToString()); EventQueueController.SendMessage(oAppStartMessage, "Application_Start"); if ((forceAppRestart)) { Config.Touch(); } }
private static void CreateContentItem(DesktopModuleInfo desktopModule) { IContentTypeController typeController = new ContentTypeController(); ContentType contentType = (from t in typeController.GetContentTypes() where t.ContentType == "DesktopModule" select t).SingleOrDefault(); if (contentType == null) { contentType = new ContentType { ContentType = "DesktopModule" }; contentType.ContentTypeId = typeController.AddContentType(contentType); } IContentController contentController = Util.GetContentController(); desktopModule.Content = desktopModule.FriendlyName; desktopModule.Indexed = false; desktopModule.ContentTypeId = contentType.ContentTypeId; desktopModule.ContentItemId = contentController.AddContentItem(desktopModule); }
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 string CreatePrivateAssembly(int DesktopModuleId) { string Result = ""; //Get the Module Definition File for this Module DesktopModuleController objDesktopModuleController = new DesktopModuleController(); DesktopModuleInfo objModule = objDesktopModuleController.GetDesktopModule(DesktopModuleId); _Folder = Globals.ApplicationMapPath + "\\DesktopModules\\" + objModule.FolderName; _AppCodeFolder = Globals.ApplicationMapPath + "\\App_Code\\" + objModule.FolderName; if (IncludeSource) { _ResourceFileName = objModule.ModuleName + "_Source.zip"; CreateResourceFile(); } //Create File List CreateFileList(); if (CreateManifest) { ProgressLog.StartJob(string.Format(Localization.GetString("LOG.PAWriter.CreateManifest"), objModule.FriendlyName)); CreateDnnManifest(objModule); ProgressLog.EndJob((string.Format(Localization.GetString("LOG.PAWriter.CreateManifest"), objModule.FriendlyName))); } //Always add Manifest file to file list AddFile(new PaFileInfo(objModule.ModuleName + ".dnn", "", Folder), true); ProgressLog.StartJob(string.Format(Localization.GetString("LOG.PAWriter.CreateZipFile"), objModule.FriendlyName)); CreateZipFile(); ProgressLog.EndJob((string.Format(Localization.GetString("LOG.PAWriter.CreateZipFile"), objModule.FriendlyName))); return(Result); }
internal static void AddDesktopModuleToPage(DesktopModuleInfo desktopModule, TabInfo tab, ref bool addedNewModule) { if (tab.PortalID != Null.NullInteger) { AddDesktopModuleToPortal(tab.PortalID, desktopModule.DesktopModuleID, !desktopModule.IsAdmin, false); } var moduleDefinitions = ModuleDefinitionController.GetModuleDefinitionsByDesktopModuleID(desktopModule.DesktopModuleID).Values; var tabModules = ModuleController.Instance.GetTabModules(tab.TabID).Values; foreach (var moduleDefinition in moduleDefinitions) { if (tabModules.All(m => m.ModuleDefinition.ModuleDefID != moduleDefinition.ModuleDefID)) { Upgrade.AddModuleToPage(tab, moduleDefinition.ModuleDefID, desktopModule.Page.Description, desktopModule.Page.Icon, true); addedNewModule = true; } } }
internal static int SaveDesktopModule(DesktopModuleInfo desktopModule, bool saveChildren, bool clearCache, bool saveTerms) { var desktopModuleID = desktopModule.DesktopModuleID; if (desktopModuleID == Null.NullInteger) { CreateContentItem(desktopModule); desktopModuleID = DataProvider.AddDesktopModule(desktopModule.PackageID, desktopModule.ModuleName, desktopModule.FolderName, desktopModule.FriendlyName, desktopModule.Description, desktopModule.Version, desktopModule.IsPremium, desktopModule.IsAdmin, desktopModule.BusinessControllerClass, desktopModule.SupportedFeatures, (int)desktopModule.Shareable, desktopModule.CompatibleVersions, desktopModule.Dependencies, desktopModule.Permissions, desktopModule.ContentItemId, UserController.Instance.GetCurrentUserInfo().UserID, desktopModule.AdminPage, desktopModule.HostPage); EventLogController.Instance.AddLog(desktopModule, PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.DESKTOPMODULE_CREATED); } else { //Update ContentItem If neccessary if (desktopModule.ContentItemId == Null.NullInteger) { CreateContentItem(desktopModule); } DataProvider.UpdateDesktopModule(desktopModule.DesktopModuleID, desktopModule.PackageID, desktopModule.ModuleName, desktopModule.FolderName, desktopModule.FriendlyName, desktopModule.Description, desktopModule.Version, desktopModule.IsPremium, desktopModule.IsAdmin, desktopModule.BusinessControllerClass, desktopModule.SupportedFeatures, (int)desktopModule.Shareable, desktopModule.CompatibleVersions, desktopModule.Dependencies, desktopModule.Permissions, desktopModule.ContentItemId, UserController.Instance.GetCurrentUserInfo().UserID, desktopModule.AdminPage, desktopModule.HostPage); //Update Tags if (saveTerms) { var termController = Util.GetTermController(); termController.RemoveTermsFromContent(desktopModule); foreach (var term in desktopModule.Terms) { termController.AddTermToContent(term, desktopModule); } } EventLogController.Instance.AddLog(desktopModule, PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.DESKTOPMODULE_UPDATED); } if (saveChildren) { foreach (var definition in desktopModule.ModuleDefinitions.Values) { definition.DesktopModuleID = desktopModuleID; var moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByDefinitionName(definition.DefinitionName, desktopModuleID); if (moduleDefinition != null) { definition.ModuleDefID = moduleDefinition.ModuleDefID; } ModuleDefinitionController.SaveModuleDefinition(definition, true, clearCache); } } if (clearCache) { DataCache.ClearHostCache(true); } return(desktopModuleID); }
public void UpdateDesktopModule(DesktopModuleInfo objDesktopModule) { DataProvider.Instance().UpdateDesktopModule(objDesktopModule.DesktopModuleID, objDesktopModule.ModuleName, objDesktopModule.FolderName, objDesktopModule.FriendlyName, objDesktopModule.Description, objDesktopModule.Version, objDesktopModule.IsPremium, objDesktopModule.IsAdmin, objDesktopModule.BusinessControllerClass, objDesktopModule.SupportedFeatures, objDesktopModule.CompatibleVersions); }
/// ----------------------------------------------------------------------------- /// <summary> /// DeleteDesktopModule deletes a Desktop Module /// </summary> /// <param name="objDesktopModule">Desktop Module Info</param> /// ----------------------------------------------------------------------------- public void DeleteDesktopModule(DesktopModuleInfo objDesktopModule) { DeleteDesktopModule(objDesktopModule.DesktopModuleID); }
/// <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> /// <param name="Controller">The Controller Class string</param> /// <param name="Version">The Module Version</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, bool Premium, bool Admin, string Controller, string Version) { DesktopModuleController objDesktopModules = new DesktopModuleController(); // check if desktop module exists DesktopModuleInfo objDesktopModule = objDesktopModules.GetDesktopModuleByName(DesktopModuleName); if (objDesktopModule == null) { objDesktopModule = new DesktopModuleInfo(); objDesktopModule.DesktopModuleID = Null.NullInteger; objDesktopModule.FriendlyName = DesktopModuleName; objDesktopModule.FolderName = DesktopModuleName; objDesktopModule.ModuleName = DesktopModuleName; objDesktopModule.Description = Description; objDesktopModule.Version = Version; objDesktopModule.IsPremium = Premium; objDesktopModule.IsAdmin = Admin; objDesktopModule.BusinessControllerClass = Controller; objDesktopModule.DesktopModuleID = objDesktopModules.AddDesktopModule(objDesktopModule); } ModuleDefinitionController objModuleDefinitions = new ModuleDefinitionController(); // check if module definition exists ModuleDefinitionInfo objModuleDefinition = objModuleDefinitions.GetModuleDefinitionByName(objDesktopModule.DesktopModuleID, ModuleDefinitionName); if (objModuleDefinition == null) { objModuleDefinition = new ModuleDefinitionInfo(); objModuleDefinition.ModuleDefID = Null.NullInteger; objModuleDefinition.DesktopModuleID = objDesktopModule.DesktopModuleID; objModuleDefinition.FriendlyName = ModuleDefinitionName; objModuleDefinition.ModuleDefID = objModuleDefinitions.AddModuleDefinition(objModuleDefinition); } return objModuleDefinition.ModuleDefID; }
/// ----------------------------------------------------------------------------- /// <summary> /// The ReadManifest method reads the manifest file for the Module compoent. /// </summary> /// <history> /// [cnurse] 01/15/2008 created /// </history> /// ----------------------------------------------------------------------------- public override void ReadManifest(XPathNavigator manifestNav) { //Load the Desktop Module from the manifest _desktopModule = CBO.DeserializeObject<DesktopModuleInfo>(new StringReader(manifestNav.InnerXml)); _desktopModule.FriendlyName = Package.FriendlyName; _desktopModule.Description = Package.Description; _desktopModule.Version = Globals.FormatVersion(Package.Version); _desktopModule.CompatibleVersions = Null.NullString; _desktopModule.Dependencies = Null.NullString; _desktopModule.Permissions = Null.NullString; if (string.IsNullOrEmpty(_desktopModule.BusinessControllerClass)) { _desktopModule.SupportedFeatures = 0; } XPathNavigator eventMessageNav = manifestNav.SelectSingleNode("eventMessage"); if (eventMessageNav != null) { _eventMessage = new EventMessage { Priority = MessagePriority.High, ExpirationDate = DateTime.Now.AddYears(-1), SentDate = DateTime.Now, Body = "", ProcessorType = Util.ReadElement(eventMessageNav, "processorType", Log, Util.EVENTMESSAGE_TypeMissing), ProcessorCommand = Util.ReadElement(eventMessageNav, "processorCommand", Log, Util.EVENTMESSAGE_CommandMissing) }; foreach (XPathNavigator attributeNav in eventMessageNav.Select("attributes/*")) { var attribName = attributeNav.Name; var attribValue = attributeNav.Value; if (attribName == "upgradeVersionsList") { if (!String.IsNullOrEmpty(attribValue)) { string[] upgradeVersions = attribValue.Split(','); attribValue = ""; foreach (string version in upgradeVersions) { Version upgradeVersion = null; try { upgradeVersion = new Version(version); } catch (FormatException) { Log.AddWarning(string.Format(Util.MODULE_InvalidVersion, version)); } if (upgradeVersion != null && (Globals.Status == Globals.UpgradeStatus.Install)) //To allow when fresh installing or installresources { attribValue += version + ","; } else if (upgradeVersion != null && upgradeVersion > Package.InstalledVersion) { attribValue += version + ","; } } attribValue = attribValue.TrimEnd(','); } } _eventMessage.Attributes.Add(attribName, attribValue); } } //Load permissions (to add) foreach (XPathNavigator moduleDefinitionNav in manifestNav.Select("desktopModule/moduleDefinitions/moduleDefinition")) { string friendlyName = Util.ReadElement(moduleDefinitionNav, "friendlyName"); foreach (XPathNavigator permissionNav in moduleDefinitionNav.Select("permissions/permission")) { var permission = new PermissionInfo(); permission.PermissionCode = Util.ReadAttribute(permissionNav, "code"); permission.PermissionKey = Util.ReadAttribute(permissionNav, "key"); permission.PermissionName = Util.ReadAttribute(permissionNav, "name"); ModuleDefinitionInfo moduleDefinition = _desktopModule.ModuleDefinitions[friendlyName]; if (moduleDefinition != null) { moduleDefinition.Permissions.Add(permission.PermissionKey, permission); } } } if (Log.Valid) { Log.AddInfo(Util.MODULE_ReadSuccess); } }
/// ----------------------------------------------------------------------------- /// <summary> /// wizNewExtension_NextButtonClick when the next Button is clicked. It provides /// a mechanism for cancelling the page change if certain conditions aren't met. /// </summary> /// <remarks> /// </remarks> /// <history> /// [cnurse] 08/25/2008 created /// </history> /// ----------------------------------------------------------------------------- protected void wizNewExtension_NextButtonClick(object sender, WizardNavigationEventArgs e) { switch (e.CurrentStepIndex) { case 0: if (extensionForm.IsValid) { var newPackage = extensionForm.DataSource as PackageInfo; PackageInfo tmpPackage = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.Name == newPackage.Name); if (tmpPackage == null) { switch (Mode) { case "All": newPackage.PackageType = cboExtensionType.SelectedValue; break; default: newPackage.PackageType = Mode; break; } PackageController.Instance.SaveExtensionPackage(newPackage); Locale locale; LanguagePackInfo languagePack; switch (newPackage.PackageType) { case "Auth_System": //Create a new Auth System var authSystem = new AuthenticationInfo { AuthenticationType = newPackage.Name, IsEnabled = Null.NullBoolean, PackageID = newPackage.PackageID }; AuthenticationController.AddAuthentication(authSystem); break; case "Container": case "Skin": var skinPackage = new SkinPackageInfo { SkinName = newPackage.Name, PackageID = newPackage.PackageID, SkinType = newPackage.PackageType }; SkinController.AddSkinPackage(skinPackage); break; case "CoreLanguagePack": locale = LocaleController.Instance.GetLocale(PortalController.Instance.GetCurrentPortalSettings().DefaultLanguage); languagePack = new LanguagePackInfo { PackageID = newPackage.PackageID, LanguageID = locale.LanguageId, DependentPackageID = -2 }; LanguagePackController.SaveLanguagePack(languagePack); break; case "ExtensionLanguagePack": locale = LocaleController.Instance.GetLocale(PortalController.Instance.GetCurrentPortalSettings().DefaultLanguage); languagePack = new LanguagePackInfo { PackageID = newPackage.PackageID, LanguageID = locale.LanguageId, DependentPackageID = Null.NullInteger }; LanguagePackController.SaveLanguagePack(languagePack); break; case "Module": //Create a new DesktopModule var desktopModule = new DesktopModuleInfo { PackageID = newPackage.PackageID, ModuleName = newPackage.Name, FriendlyName = newPackage.FriendlyName, FolderName = newPackage.Name, Description = newPackage.Description, Version = newPackage.Version.ToString(3), SupportedFeatures = 0 }; int desktopModuleId = DesktopModuleController.SaveDesktopModule(desktopModule, false, true); if (desktopModuleId > Null.NullInteger) { DesktopModuleController.AddDesktopModuleToPortals(desktopModuleId); } break; case "SkinObject": var skinControl = new SkinControlInfo { PackageID = newPackage.PackageID, ControlKey = newPackage.Name }; SkinControlController.SaveSkinControl(skinControl); break; } } else { e.Cancel = true; lblError.Text = string.Format(Localization.GetString("DuplicateName", LocalResourceFile), newPackage.Name); lblError.Visible = true; } } if (PackageEditor != null && PackageID > Null.NullInteger) { BindPackageEditor(); } break; case 1: if (PackageEditor != null) { PackageEditor.UpdatePackage(); } break; case 2: if (ownerForm.IsValid) { PackageController.Instance.SaveExtensionPackage(ownerForm.DataSource as PackageInfo); } Response.Redirect(Globals.NavigateURL(), true); break; } }
public void UpdateModuleInterfaces(ref DesktopModuleInfo desktopModuleInfo, string sender, bool forceAppRestart) { CheckInterfacesImplementation(ref desktopModuleInfo); var oAppStartMessage = new EventMessage { Sender = sender, Priority = MessagePriority.High, ExpirationDate = DateTime.Now.AddYears(-1), SentDate = DateTime.Now, Body = "", ProcessorType = "DotNetNuke.Entities.Modules.EventMessageProcessor, DotNetNuke", ProcessorCommand = "UpdateSupportedFeatures" }; oAppStartMessage.Attributes.Add("BusinessControllerClass", desktopModuleInfo.BusinessControllerClass); oAppStartMessage.Attributes.Add("DesktopModuleId", desktopModuleInfo.DesktopModuleID.ToString()); EventQueueController.SendMessage(oAppStartMessage, "Application_Start"); if ((forceAppRestart)) { Config.Touch(); } }
private void CreateModulePackage(DesktopModuleInfo desktopModule, bool createZip) { PackageInfo modulePackage = PackageController.GetPackage(desktopModule.PackageID); var Package = new PackageInfo(); Package.Name = modulePackage.Name; Package.FriendlyName = modulePackage.Name; Package.Version = modulePackage.Version; Package.License = Util.PACKAGE_NoLicense; string fileName = Path.Combine(BasePath, "ResourcePack." + Package.Name); CreatePackage(Package, modulePackage.PackageID, Path.Combine("DesktopModules\\", desktopModule.FolderName), fileName, createZip); }
internal static int SaveDesktopModule(DesktopModuleInfo desktopModule, bool saveChildren, bool clearCache, bool saveTerms) { var desktopModuleID = desktopModule.DesktopModuleID; var eventLogController = new EventLogController(); if (desktopModuleID == Null.NullInteger) { CreateContentItem(desktopModule); desktopModuleID = DataProvider.AddDesktopModule(desktopModule.PackageID, desktopModule.ModuleName, desktopModule.FolderName, desktopModule.FriendlyName, desktopModule.Description, desktopModule.Version, desktopModule.IsPremium, desktopModule.IsAdmin, desktopModule.BusinessControllerClass, desktopModule.SupportedFeatures, (int)desktopModule.Shareable, desktopModule.CompatibleVersions, desktopModule.Dependencies, desktopModule.Permissions, desktopModule.ContentItemId, UserController.GetCurrentUserInfo().UserID); eventLogController.AddLog(desktopModule, PortalController.GetCurrentPortalSettings(), UserController.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.DESKTOPMODULE_CREATED); } else { //Update ContentItem If neccessary if (desktopModule.ContentItemId == Null.NullInteger) { CreateContentItem(desktopModule); } DataProvider.UpdateDesktopModule(desktopModule.DesktopModuleID, desktopModule.PackageID, desktopModule.ModuleName, desktopModule.FolderName, desktopModule.FriendlyName, desktopModule.Description, desktopModule.Version, desktopModule.IsPremium, desktopModule.IsAdmin, desktopModule.BusinessControllerClass, desktopModule.SupportedFeatures, (int)desktopModule.Shareable, desktopModule.CompatibleVersions, desktopModule.Dependencies, desktopModule.Permissions, desktopModule.ContentItemId, UserController.GetCurrentUserInfo().UserID); //Update Tags if (saveTerms) { var termController = Util.GetTermController(); termController.RemoveTermsFromContent(desktopModule); foreach (var term in desktopModule.Terms) { termController.AddTermToContent(term, desktopModule); } } eventLogController.AddLog(desktopModule, PortalController.GetCurrentPortalSettings(), UserController.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.DESKTOPMODULE_UPDATED); } if (saveChildren) { foreach (var definition in desktopModule.ModuleDefinitions.Values) { definition.DesktopModuleID = desktopModuleID; var moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByDefinitionName(definition.DefinitionName, desktopModuleID); if (moduleDefinition != null) { definition.ModuleDefID = moduleDefinition.ModuleDefID; } ModuleDefinitionController.SaveModuleDefinition(definition, true, clearCache); } } if (clearCache) { DataCache.ClearHostCache(true); } return desktopModuleID; }
public void UpdateModuleInterfaces(ref DesktopModuleInfo desktopModuleInfo) { UpdateModuleInterfaces(ref desktopModuleInfo, (UserController.GetCurrentUserInfo() == null) ? "" : UserController.GetCurrentUserInfo().Username, true); }
/// ----------------------------------------------------------------------------- /// <summary> /// SaveDesktopModule saves the Desktop Module to the database /// </summary> /// <param name="desktopModule">The Desktop Module to save</param> /// <param name="saveChildren">A flag that determines whether the child objects are also saved</param> /// <param name="clearCache">A flag that determines whether to clear the host cache</param> /// <history> /// [cnurse] 01/13/2008 Created /// </history> /// ----------------------------------------------------------------------------- public static int SaveDesktopModule(DesktopModuleInfo desktopModule, bool saveChildren, bool clearCache) { return SaveDesktopModule(desktopModule, saveChildren, clearCache, true); }
/// ----------------------------------------------------------------------------- /// <summary> /// DeleteDesktopModule deletes a Desktop Module /// </summary> /// <param name="objDesktopModule">Desktop Module Info</param> /// <history> /// [cnurse] 05/14/2009 Documented /// </history> /// ----------------------------------------------------------------------------- public void DeleteDesktopModule(DesktopModuleInfo objDesktopModule) { DeleteDesktopModule(objDesktopModule.DesktopModuleID); }
protected override string UpgradeModule(DesktopModuleInfo ModuleInfo) { if (!String.IsNullOrEmpty(ModuleInfo.BusinessControllerClass)) { string UpgradeVersionsList = ""; if (UpgradeVersions.Count > 0) { foreach (string Version in UpgradeVersions) { UpgradeVersionsList = UpgradeVersionsList + Version + ","; DeleteFiles(ModuleInfo.FolderName, Version); } if (UpgradeVersionsList.EndsWith(",")) { UpgradeVersionsList = UpgradeVersionsList.Remove(UpgradeVersionsList.Length - 1, 1); } } else { UpgradeVersionsList = ModuleInfo.Version; } //this cannot be done directly at this time because //the module may not be loaded into the app domain yet //So send an EventMessage that will process the update //after the App recycles EventMessage oAppStartMessage = new EventMessage(); oAppStartMessage.ProcessorType = "DotNetNuke.Entities.Modules.EventMessageProcessor, DotNetNuke"; oAppStartMessage.Attributes.Add("ProcessCommand", "UpgradeModule"); oAppStartMessage.Attributes.Add("BusinessControllerClass", ModuleInfo.BusinessControllerClass); oAppStartMessage.Attributes.Add("DesktopModuleId", ModuleInfo.DesktopModuleID.ToString()); oAppStartMessage.Attributes.Add("UpgradeVersionsList", UpgradeVersionsList); oAppStartMessage.Priority = MessagePriority.High; oAppStartMessage.SentDate = DateTime.Now; //make it expire as soon as it's processed oAppStartMessage.ExpirationDate = DateTime.Now.AddYears(-1); //send it EventQueueController oEventQueueController = new EventQueueController(); oEventQueueController.SendMessage(oAppStartMessage, "Application_Start"); } //TODO: Need to implement a feedback loop to display the results of the upgrade. return ""; }
private void CheckInterfacesImplementation(ref DesktopModuleInfo desktopModuleInfo) { var businessController = Reflection.CreateType(desktopModuleInfo.BusinessControllerClass); var controller = Reflection.CreateObject(desktopModuleInfo.BusinessControllerClass, desktopModuleInfo.BusinessControllerClass); desktopModuleInfo.IsPortable = businessController.GetInterfaces().Contains(typeof (IPortable)); #pragma warning disable 0618 desktopModuleInfo.IsSearchable = (controller is ModuleSearchBase) || businessController.GetInterfaces().Contains(typeof(ISearchable)); #pragma warning restore 0618 desktopModuleInfo.IsUpgradeable = businessController.GetInterfaces().Contains(typeof(IUpgradeable)); }
/// <summary> /// </summary> /// <remarks> /// Loads the cboSource control list with locations of controls. /// </remarks> /// <history> /// </history> private ModuleDefinitionInfo ImportControl(string controlSrc) { ModuleDefinitionInfo moduleDefinition = null; try { string folder = PathUtils.Instance.RemoveTrailingSlash(GetSourceFolder()); string friendlyName = txtName.Text; string name = GetClassName(); string moduleControl = "DesktopModules/" + folder + "/" + controlSrc; var packageInfo = PackageController.GetPackages().FirstOrDefault(p => p.Name == name || p.FriendlyName == friendlyName); if (packageInfo != null) { UI.Skins.Skin.AddModuleMessage(this, String.Format(Localization.GetString("NonuniqueNameModule", LocalResourceFile), packageInfo.FriendlyName), ModuleMessage.ModuleMessageType.RedError); } else { var package = new PackageInfo(); package.Name = name; package.FriendlyName = friendlyName; package.Description = txtDescription.Text; package.Version = new Version(1, 0, 0); package.PackageType = "Module"; package.License = Util.PACKAGE_NoLicense; //Save Package PackageController.SavePackage(package); var objDesktopModules = new DesktopModuleController(); var objDesktopModule = new DesktopModuleInfo(); objDesktopModule.DesktopModuleID = Null.NullInteger; objDesktopModule.ModuleName = name; objDesktopModule.FolderName = folder; objDesktopModule.FriendlyName = friendlyName; 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 = package.PackageID; #pragma warning disable 612,618 objDesktopModule.DesktopModuleID = objDesktopModules.AddDesktopModule(objDesktopModule); #pragma warning restore 612,618 //Add module to all portals DesktopModuleController.AddDesktopModuleToPortals(objDesktopModule.DesktopModuleID); //Save module definition moduleDefinition = new ModuleDefinitionInfo(); moduleDefinition.ModuleDefID = Null.NullInteger; moduleDefinition.DesktopModuleID = objDesktopModule.DesktopModuleID; moduleDefinition.FriendlyName = friendlyName; moduleDefinition.DefaultCacheTime = 0; moduleDefinition.ModuleDefID = ModuleDefinitionController.SaveModuleDefinition(moduleDefinition, false, true); //Save module control var objModuleControl = new ModuleControlInfo(); objModuleControl.ModuleControlID = Null.NullInteger; objModuleControl.ModuleDefID = moduleDefinition.ModuleDefID; objModuleControl.ControlKey = ""; objModuleControl.ControlSrc = moduleControl; objModuleControl.ControlTitle = ""; objModuleControl.ControlType = SecurityAccessLevel.View; objModuleControl.HelpURL = ""; objModuleControl.IconFile = ""; objModuleControl.ViewOrder = 0; objModuleControl.SupportsPartialRendering = false; ModuleControlController.AddModuleControl(objModuleControl); } } catch (Exception exc) { Exceptions.LogException(exc); UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("ImportControl.ErrorMessage", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError); } return moduleDefinition; }
public int AddDesktopModule(DesktopModuleInfo objDesktopModule) { return(SaveDesktopModule(objDesktopModule, false, true)); }
/// ----------------------------------------------------------------------------- /// <summary> /// The Install method installs the Module component /// </summary> /// <history> /// [cnurse] 01/15/2008 created /// </history> /// ----------------------------------------------------------------------------- public override void Install() { try { //Attempt to get the Desktop Module _installedDesktopModule = DesktopModuleController.GetDesktopModuleByModuleName(_desktopModule.ModuleName, Package.InstallerInfo.PortalID); if (_installedDesktopModule != null) { _desktopModule.DesktopModuleID = _installedDesktopModule.DesktopModuleID; //save the module's category _desktopModule.Category = _installedDesktopModule.Category; } //Clear ModuleControls and Module Definitions caches in case script has modifed the contents DataCache.RemoveCache(DataCache.ModuleDefinitionCacheKey); DataCache.RemoveCache(DataCache.ModuleControlsCacheKey); //Save DesktopModule and child objects to database _desktopModule.PackageID = Package.PackageID; _desktopModule.DesktopModuleID = DesktopModuleController.SaveDesktopModule(_desktopModule, true, false); Completed = true; Log.AddInfo(string.Format(Util.MODULE_Registered, _desktopModule.ModuleName)); } catch (Exception ex) { Log.AddFailure(ex); } }
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); } }
/// <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; } }
/// <summary> /// cmdUpdate_Click runs when the Update Button is clicked /// </summary> /// <history> /// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support /// and localisation /// </history> protected void cmdUpdate_Click( object sender, EventArgs e ) { try { if( Page.IsValid ) { DesktopModuleInfo objDesktopModule = new DesktopModuleInfo(); objDesktopModule.DesktopModuleID = DesktopModuleId; objDesktopModule.ModuleName = txtModuleName.Text; objDesktopModule.FolderName = txtFolderName.Text; objDesktopModule.FriendlyName = txtFriendlyName.Text; if( objDesktopModule.FolderName == "" ) { objDesktopModule.FolderName = objDesktopModule.ModuleName; } objDesktopModule.Description = txtDescription.Text; objDesktopModule.IsPremium = chkPremium.Checked; objDesktopModule.IsAdmin = false; if( !String.IsNullOrEmpty(txtVersion.Text) ) { objDesktopModule.Version = txtVersion.Text; } else { objDesktopModule.Version = Null.NullString; } if( !String.IsNullOrEmpty(txtBusinessClass.Text) ) { objDesktopModule.BusinessControllerClass = txtBusinessClass.Text; } else { objDesktopModule.BusinessControllerClass = Null.NullString; } if (!String.IsNullOrEmpty( txtCompatibleVersions.Text)) { objDesktopModule.CompatibleVersions = txtCompatibleVersions.Text; } else { objDesktopModule.CompatibleVersions = Null.NullString; } DesktopModuleController objDesktopModules = new DesktopModuleController(); if( Null.IsNull( DesktopModuleId ) ) { try { objDesktopModule.DesktopModuleID = objDesktopModules.AddDesktopModule( objDesktopModule ); } catch { UI.Skins.Skin.AddModuleMessage( this, Localization.GetString( "AddModule.ErrorMessage", this.LocalResourceFile ), ModuleMessageType.RedError ); return; } } else { objDesktopModules.UpdateDesktopModule( objDesktopModule ); } // delete old portal module assignments objDesktopModules.DeletePortalDesktopModules( Null.NullInteger, objDesktopModule.DesktopModuleID ); // add new portal module assignments if( objDesktopModule.IsPremium ) { foreach( ListItem objListItem in ctlPortals.Assigned ) { objDesktopModules.AddPortalDesktopModule( int.Parse( objListItem.Value ), objDesktopModule.DesktopModuleID ); } } // update interfaces UpdateModuleInterfaces( objDesktopModule.BusinessControllerClass ); Response.Redirect( EditUrl( "desktopmoduleid", objDesktopModule.DesktopModuleID.ToString() ), true ); } } catch( Exception exc ) //Module failed to load { Exceptions.ProcessModuleLoadException( this, exc ); } }
protected void cmdDeleteDefinition_Click(object sender, EventArgs e) { var objModuleDefinitions = new ModuleDefinitionController(); objModuleDefinitions.DeleteModuleDefinition(ModuleDefinitionID); //Force Definitions list to refresh by rebinding DesktopModule ModuleDefinitionID = Null.NullInteger; _ModuleDefinition = null; _DesktopModule = null; BindDesktopModule(true); }
/// <summary> /// Creates the DNN manifest. /// </summary> /// <param name="objDesktopModule">The obj desktop module.</param> private void CreateDnnManifest(DesktopModuleInfo objDesktopModule) { string filename = ""; _Name = objDesktopModule.ModuleName; //Create Manifest Document XmlDocument xmlManifest = new XmlDocument(); //Root Element XmlNode nodeRoot = xmlManifest.CreateElement("dotnetnuke"); nodeRoot.Attributes.Append(XmlUtils.CreateAttribute(xmlManifest, "version", "3.0")); nodeRoot.Attributes.Append(XmlUtils.CreateAttribute(xmlManifest, "type", "Module")); //Folders Element XmlNode nodeFolders = xmlManifest.CreateElement("folders"); nodeRoot.AppendChild(nodeFolders); //Folder Element XmlNode nodeFolder = xmlManifest.CreateElement("folder"); nodeFolders.AppendChild(nodeFolder); //Desktop Module Info nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "name", _Name)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "friendlyname", objDesktopModule.FriendlyName)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "foldername", objDesktopModule.FolderName)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "modulename", _Name)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "description", objDesktopModule.Description)); if (objDesktopModule.Version == Null.NullString) { objDesktopModule.Version = "01.00.00"; } nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "version", objDesktopModule.Version)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "businesscontrollerclass", objDesktopModule.BusinessControllerClass)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "version", objDesktopModule.Version)); nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "businesscontrollerclass", objDesktopModule.BusinessControllerClass)); if (objDesktopModule.CompatibleVersions != "") { nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "compatibleversions", objDesktopModule.CompatibleVersions)); } if (SupportsProbingPrivatePath) { nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "supportsprobingprivatepath", SupportsProbingPrivatePath.ToString())); } //Add Source files if (IncludeSource) { nodeFolder.AppendChild(XmlUtils.CreateElement(xmlManifest, "resourcefile", ResourceFileName)); } //Modules Element XmlNode nodeModules = xmlManifest.CreateElement("modules"); nodeFolder.AppendChild(nodeModules); //Get the Module Definitions for this Module ModuleDefinitionController objModuleDefinitionController = new ModuleDefinitionController(); ArrayList arrModuleDefinitions = objModuleDefinitionController.GetModuleDefinitions(objDesktopModule.DesktopModuleID); //Iterate through Module Definitions foreach (ModuleDefinitionInfo objModuleInfo in arrModuleDefinitions) { XmlNode nodeModule = xmlManifest.CreateElement("module"); //Add module definition properties nodeModule.AppendChild(XmlUtils.CreateElement(xmlManifest, "friendlyname", objModuleInfo.FriendlyName)); //Add Cache properties nodeModule.AppendChild(XmlUtils.CreateElement(xmlManifest, "cachetime", objModuleInfo.DefaultCacheTime.ToString())); //Get the Module Controls for this Module Definition ModuleControlController objModuleControlController = new ModuleControlController(); ArrayList arrModuleControls = objModuleControlController.GetModuleControls(objModuleInfo.ModuleDefID); //Controls Element XmlNode nodeControls = xmlManifest.CreateElement("controls"); nodeModule.AppendChild(nodeControls); //Iterate through Module Controls foreach (ModuleControlInfo objModuleControl in arrModuleControls) { XmlNode nodeControl = xmlManifest.CreateElement("control"); //Add module control properties XmlUtils.AppendElement(ref xmlManifest, nodeControl, "key", objModuleControl.ControlKey, false); XmlUtils.AppendElement(ref xmlManifest, nodeControl, "title", objModuleControl.ControlTitle, false); XmlUtils.AppendElement(ref xmlManifest, nodeControl, "src", objModuleControl.ControlSrc, true); XmlUtils.AppendElement(ref xmlManifest, nodeControl, "iconfile", objModuleControl.IconFile, false); XmlUtils.AppendElement(ref xmlManifest, nodeControl, "type", objModuleControl.ControlType.ToString(), true); XmlUtils.AppendElement(ref xmlManifest, nodeControl, "helpurl", objModuleControl.HelpURL, false); //Add control Node to controls nodeControls.AppendChild(nodeControl); //Determine the filename for the Manifest file (It should be saved with the other Module files) if (filename == "") { filename = Folder + "\\" + objDesktopModule.ModuleName + ".dnn"; } } //Add module Node to modules nodeModules.AppendChild(nodeModule); } //Files Element XmlNode nodeFiles = xmlManifest.CreateElement("files"); nodeFolder.AppendChild(nodeFiles); //Add the files foreach (PaFileInfo file in _Files) { XmlNode nodeFile = xmlManifest.CreateElement("file"); //Add file properties XmlUtils.AppendElement(ref xmlManifest, nodeFile, "path", file.Path, false); XmlUtils.AppendElement(ref xmlManifest, nodeFile, "name", file.Name, false); //Add file Node to files nodeFiles.AppendChild(nodeFile); } //Add Root element to document xmlManifest.AppendChild(nodeRoot); //Save Manifest file xmlManifest.Save(filename); }
public ModulePackageWriter(DesktopModuleInfo desktopModule, PackageInfo package) : base(package) { DesktopModule = desktopModule; Initialize(desktopModule.FolderName); }
/// ----------------------------------------------------------------------------- /// <summary> /// SaveDesktopModule saves the Desktop Module to the database /// </summary> /// <param name="desktopModule">The Desktop Module to save</param> /// <param name="saveChildren">A flag that determines whether the child objects are also saved</param> /// <param name="clearCache">A flag that determines whether to clear the host cache</param> /// ----------------------------------------------------------------------------- public static int SaveDesktopModule(DesktopModuleInfo desktopModule, bool saveChildren, bool clearCache) { return(SaveDesktopModule(desktopModule, saveChildren, clearCache, true)); }
protected void cmdDeleteDefinition_Click(object sender, EventArgs e) { var objModuleDefinitions = new ModuleDefinitionController(); objModuleDefinitions.DeleteModuleDefinition(ModuleDefinitionID); //Force Definitions list to refresh by rebinding DesktopModule ModuleDefinitionID = Null.NullInteger; _ModuleDefinition = null; _DesktopModule = null; //empty definition form's content definitionsEditor.Items.ForEach(i => { i.Value = null; }); BindDesktopModule(true); }
public void UpdateModuleInterfaces(ref DesktopModuleInfo desktopModuleInfo) { UpdateModuleInterfaces(ref desktopModuleInfo, (UserController.Instance.GetCurrentUserInfo() == null) ? "" : UserController.Instance.GetCurrentUserInfo().Username, true); }
protected void cmdUpdateDefinition_Click(object sender, EventArgs e) { if (definitionsEditor.IsValid) { var definition = definitionsEditor.DataSource as ModuleDefinitionInfo; if (definition != null) { if ((IsAddDefinitionMode && ModuleDefinitionController.GetModuleDefinitionByFriendlyName(definition.FriendlyName) == null) || (!IsAddDefinitionMode)) { ModuleDefinitionID = ModuleDefinitionController.SaveModuleDefinition(definition, false, true); //Force Definitions list to refresh by rebinding DesktopModule IsAddDefinitionMode = false; _DesktopModule = null; BindDesktopModule(true); } else { //The FriendlyName is being used lblDefinitionError.Visible = true; } } } }
public static int AddDesktopModuleToPortal(int portalID, DesktopModuleInfo desktopModule, DesktopModulePermissionCollection permissions, bool clearCache) { int portalDesktopModuleID = AddDesktopModuleToPortal(portalID, desktopModule.DesktopModuleID, false, clearCache); if (portalDesktopModuleID > Null.NullInteger) { DesktopModulePermissionController.DeleteDesktopModulePermissionsByPortalDesktopModuleID(portalDesktopModuleID); foreach (DesktopModulePermissionInfo permission in permissions) { permission.PortalDesktopModuleID = portalDesktopModuleID; DesktopModulePermissionController.AddDesktopModulePermission(permission); } } return portalDesktopModuleID; }
protected override DesktopModuleInfo GetDesktopModuleSettings(DesktopModuleInfo objDesktopModule, PaFolder Folder) { // call the V2 implementation to load the values objDesktopModule = base.GetDesktopModuleSettings(objDesktopModule, Folder); // V3 .dnn file format adds the optional businesscontrollerclass node to the folder node element objDesktopModule.BusinessControllerClass = Folder.BusinessControllerClass; // V4.3.6 .dnn file format adds the optional compatibleversions node to the folder node element objDesktopModule.CompatibleVersions = Folder.CompatibleVersions; //V3.1 adds the IsSearchable/IsPortable properties - set them to false objDesktopModule.IsSearchable = false; objDesktopModule.IsPortable = false; //Create an instance of the business controller and determine the values of IsSearchable and //IsPortable by Reflection try { if (!String.IsNullOrEmpty(objDesktopModule.BusinessControllerClass)) { object objController = Reflection.CreateObject(objDesktopModule.BusinessControllerClass, objDesktopModule.BusinessControllerClass); if (objController is ISearchable) { objDesktopModule.IsSearchable = true; } if (objController is IPortable) { objDesktopModule.IsPortable = true; } } } catch { //this code may not work because the module may have just been upgraded and did not have //the BusinessControllerClass in the version that is currently in the Application Domain //if this is the case, then the updating of thos features will be handled after the application is restarted } return objDesktopModule; }
public void UpdateDesktopModule(DesktopModuleInfo objDesktopModule) { SaveDesktopModule(objDesktopModule, false, true); }
public int AddDesktopModule(DesktopModuleInfo objDesktopModule) { return SaveDesktopModule(objDesktopModule, false, true); }
/// ----------------------------------------------------------------------------- /// <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; }