public override void ReadManifest(XPathNavigator manifestNav)
{
DesktopModule = CBO.DeserializeObject <DesktopModuleInfo>(new StringReader(manifestNav.InnerXml));
DesktopModule.FriendlyName = Package.FriendlyName;
DesktopModule.Description = Package.Description;
DesktopModule.Version = Globals.FormatVersion(Package.Version);
//DesktopModule.IsPremium = false;
//DesktopModule.IsAdmin = false;
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 EventQueue.EventMessage();
EventMessage.Priority = MessagePriority.High;
EventMessage.ExpirationDate = DateTime.Now.AddYears(-1);
EventMessage.SentDate = System.DateTime.Now;
EventMessage.Body = "";
EventMessage.ProcessorType = Util.ReadElement(eventMessageNav, "processorType", Log, Util.EVENTMESSAGE_TypeMissing);
EventMessage.ProcessorCommand = Util.ReadElement(eventMessageNav, "processorCommand", Log, Util.EVENTMESSAGE_CommandMissing);
foreach (XPathNavigator attributeNav in eventMessageNav.Select("attributes/*"))
{
EventMessage.Attributes.Add(attributeNav.Name, attributeNav.Value);
}
}
foreach (XPathNavigator moduleDefinitionNav in manifestNav.Select("desktopModule/moduleDefinitions/moduleDefinition"))
{
string friendlyName = Util.ReadElement(moduleDefinitionNav, "friendlyName");
foreach (XPathNavigator permissionNav in moduleDefinitionNav.Select("permissions/permission"))
{
PermissionInfo 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>
/// The ReadManifest method reads the manifest file for the Module compoent.
/// </summary>
/// -----------------------------------------------------------------------------
public override void ReadManifest(XPathNavigator manifestNav)
{
// Load the Desktop Module from the manifest
this._desktopModule = CBO.DeserializeObject <DesktopModuleInfo>(new StringReader(manifestNav.InnerXml));
// Allow a <component type="Module"> (i.e. a DesktopModule) to have its own friendlyname / description.
// This allows multiple DesktopModules in one Package, allowing large MVC packages which share one assembly
// but have many functions.
if (this._desktopModule.FriendlyName == null || this._desktopModule.FriendlyName.Trim().Length == 0)
{
this._desktopModule.FriendlyName = this.Package.FriendlyName;
}
if (this._desktopModule.Description == null || this._desktopModule.Description.Trim().Length == 0)
{
this._desktopModule.Description = this.Package.Description;
}
this._desktopModule.Version = Globals.FormatVersion(this.Package.Version, "00", 4, ".");
this._desktopModule.CompatibleVersions = Null.NullString;
this._desktopModule.Dependencies = Null.NullString;
this._desktopModule.Permissions = Null.NullString;
if (string.IsNullOrEmpty(this._desktopModule.BusinessControllerClass))
{
this._desktopModule.SupportedFeatures = 0;
}
this._eventMessage = this.ReadEventMessageNode(manifestNav);
// 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 = this._desktopModule.ModuleDefinitions[friendlyName];
if (moduleDefinition != null)
{
moduleDefinition.Permissions.Add(permission.PermissionKey, permission);
}
}
}
if (this.Log.Valid)
{
this.Log.AddInfo(Util.MODULE_ReadSuccess);
}
}
/// <summary>
/// 绑定模块
/// </summary>
private void BindModules()
{
DesktopModuleInfo objDesktopModuleInfo = DesktopModuleController.GetDesktopModuleByModuleName("DNNGo.DNNGalleryPro", PortalId);
if ((objDesktopModuleInfo != null))
{
TabController objTabController = new TabController();
ArrayList objTabs = objTabController.GetTabsByPortal(PortalId).ToArrayList();
foreach (DotNetNuke.Entities.Tabs.TabInfo objTab in objTabs)
{
if ((objTab != null))
{
if ((objTab.IsDeleted == false))
{
ModuleController objModules = new ModuleController();
foreach (KeyValuePair <int, ModuleInfo> pair in objModules.GetTabModules(objTab.TabID))
{
ModuleInfo objModule = pair.Value;
if ((objModule.IsDeleted == false))
{
if ((objModule.DesktopModuleID == objDesktopModuleInfo.DesktopModuleID))
{
if (ModulePermissionController.CanEditModuleContent(objModule) & objModule.IsDeleted == false)
{
string strPath = objTab.TabName;
TabInfo objTabSelected = objTab;
while (objTabSelected.ParentId != Null.NullInteger)
{
objTabSelected = objTabController.GetTab(objTabSelected.ParentId, objTab.PortalID, false);
if ((objTabSelected == null))
{
break; // TODO: might not be correct. Was : Exit While
}
strPath = objTabSelected.TabName + " -> " + strPath;
}
ListItem objListItem = new ListItem();
objListItem.Value = objModule.TabID.ToString() + "-" + objModule.ModuleID.ToString();
objListItem.Text = strPath + " -> " + objModule.ModuleTitle;
ddlModule.Items.Add(objListItem);
}
}
}
}
}
}
}
}
}
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>
///
/// </summary>
/// <param name="Version"></param>
/// <returns></returns>
/// <remarks>This is not localizing Page Name or description.</remarks>
public string UpgradeModule(string Version)
{
try
{
switch (Version)
{
case "06.00.00":
string resourceFile = ModuleFolder + "/App_LocalResources/ProviderConfig.ascx.resx";
string pageName = Localization.GetString("HTMLEditorPageName", resourceFile);
string pageDescription = Localization.GetString("HTMLEditorPageDescription", resourceFile);
//Create Rad Editor Config Page (or get existing one)
TabInfo newPage = Upgrade.AddHostPage(pageName, pageDescription, ModuleFolder + "/images/radeditor_config_small.png", ModuleFolder + "/images/radeditor_config_large.png", true);
//Add Module To Page
int moduleDefId = GetModuleDefinitionID();
Upgrade.AddModuleToPage(newPage, moduleDefId, pageName, ModuleFolder + "/images/radeditor_config_large.png", true);
foreach (var item in DesktopModuleController.GetDesktopModules(Null.NullInteger))
{
DesktopModuleInfo moduleInfo = item.Value;
if (moduleInfo.ModuleName == "DotNetNuke.RadEditorProvider")
{
moduleInfo.Category = "Host";
DesktopModuleController.SaveDesktopModule(moduleInfo, false, false);
}
}
break;
case "07.00.06":
UpdateConfigOfLinksType();
break;
case "07.03.00":
UpdateConfigFilesName();
UpdateToolsFilesName();
break;
}
}
catch (Exception ex)
{
ExceptionLogController xlc = new ExceptionLogController();
xlc.AddLog(ex);
return("Failed");
}
return("Success");
}
protected bool ValidateVersion(PaFolder Folder)
{
// check if desktop module exists
DesktopModuleInfo objDesktopModule = GetDesktopModule(Folder);
if (objDesktopModule != null)
{
if (String.Compare(objDesktopModule.Version, Folder.Version, false) > 0)
{
return(false);
}
}
return(true);
}
private void CreateModulePackage(DesktopModuleInfo desktopModule, bool createZip)
{
PackageInfo modulePackage = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.PackageID == 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);
}
private ModuleDefinitionInfo ImportManifest(string manifest)
{
ModuleDefinitionInfo moduleDefinition = null;
try
{
var _Installer = new Installer(manifest, Request.MapPath("."), true);
if (_Installer.IsValid)
{
//Reset Log
_Installer.InstallerInfo.Log.Logs.Clear();
//Install
_Installer.Install();
if (_Installer.IsValid)
{
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(_Installer.InstallerInfo.PackageID);
if (desktopModule != null && desktopModule.ModuleDefinitions.Count > 0)
{
foreach (KeyValuePair <string, ModuleDefinitionInfo> kvp in desktopModule.ModuleDefinitions)
{
moduleDefinition = kvp.Value;
break;
}
}
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("InstallError.Text", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
phInstallLogs.Controls.Add(_Installer.InstallerInfo.Log.GetLogsTable());
}
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("InstallError.Text", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
phInstallLogs.Controls.Add(_Installer.InstallerInfo.Log.GetLogsTable());
}
}
catch (Exception exc)
{
Exceptions.LogException(exc);
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("ImportControl.ErrorMessage", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
}
return(moduleDefinition);
}
private int GetModuleDefID(string ModuleName)
{
try
{
DesktopModuleInfo desktopInfo = DesktopModuleController.GetDesktopModuleByModuleName(ModuleName, PortalController.GetCurrentPortalSettings().PortalId);
ModuleDefinitionInfo modDefInfo = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(ModuleName, desktopInfo.DesktopModuleID);
return(modDefInfo.ModuleDefID);
}
catch
{
// WStrohl:
// do nothing - an expected nullreference exception should happen here if the module is not going through the expected upgrade
return(Null.NullInteger);
}
}
public ModulePackageWriter(XPathNavigator manifestNav, InstallerInfo installer)
{
_DesktopModule = new DesktopModuleInfo();
Package = new PackageInfo(installer);
ReadLegacyManifest(manifestNav, true);
Package.Name = DesktopModule.ModuleName;
Package.FriendlyName = DesktopModule.FriendlyName;
Package.Description = DesktopModule.Description;
if (!string.IsNullOrEmpty(DesktopModule.Version))
{
Package.Version = new Version(DesktopModule.Version);
}
Package.PackageType = "Module";
LegacyUtil.ParsePackageName(Package);
Initialize(DesktopModule.FolderName);
}
private void AddModulesToList(List <PackageInfo> packages)
{
Dictionary <int, PortalDesktopModuleInfo> portalModules = DesktopModuleController.GetPortalDesktopModulesByPortalID(ModuleContext.PortalId);
foreach (PackageInfo modulePackage in PackageController.GetPackagesByType(Null.NullInteger, "Module"))
{
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(modulePackage.PackageID);
foreach (PortalDesktopModuleInfo portalModule in portalModules.Values)
{
if (desktopModule != null && portalModule.DesktopModuleID == desktopModule.DesktopModuleID)
{
packages.Add(modulePackage);
}
}
}
}
public bool CreateModulePackage(string cultureCode, DesktopModuleInfo desktopModule, bool createZip)
{
var modulePackage = PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.PackageID == desktopModule.PackageID);
var package = new PackageInfo
{
Name = modulePackage.Name,
FriendlyName = modulePackage.FriendlyName,
Version = modulePackage.Version,
License = Util.PACKAGE_NoLicense
};
var fileName = Path.Combine(this.BasePath, "ResourcePack." + package.Name);
return(this.CreatePackage(cultureCode, package, modulePackage.PackageID, Path.Combine("DesktopModules\\", desktopModule.FolderName), fileName, createZip));
}
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("");
}
/// <summary>Called when a module is upgraded.</summary>
/// <param name="version">The version.</param>
/// <returns>Success if all goes well, otherwise, Failed</returns>
public string UpgradeModule(string version)
{
try
{
switch (version)
{
case "07.04.00":
const string ResourceFile = ModuleFolder + "/App_LocalResources/ProviderConfiguration.ascx.resx";
string pageName = Localization.GetString("HTMLEditorPageName", ResourceFile);
string pageDescription = Localization.GetString("HTMLEditorPageDescription", ResourceFile);
// Create HTML Editor Config Page (or get existing one)
TabInfo editorPage = Upgrade.AddHostPage(pageName, pageDescription, ModuleFolder + "/images/HtmlEditorManager_Standard_16x16.png", ModuleFolder + "/images/HtmlEditorManager_Standard_32x32.png", true);
// Find the RadEditor control and remove it
Upgrade.RemoveModule("RadEditor Manager", editorPage.TabName, editorPage.ParentId, false);
// Add Module To Page
int moduleDefId = this.GetModuleDefinitionID("DotNetNuke.HtmlEditorManager", "Html Editor Management");
Upgrade.AddModuleToPage(editorPage, moduleDefId, pageName, ModuleFolder + "/images/HtmlEditorManager_Standard_32x32.png", true);
foreach (var item in DesktopModuleController.GetDesktopModules(Null.NullInteger))
{
DesktopModuleInfo moduleInfo = item.Value;
if (moduleInfo.ModuleName == "DotNetNuke.HtmlEditorManager")
{
moduleInfo.Category = "Host";
DesktopModuleController.SaveDesktopModule(moduleInfo, false, false);
}
}
break;
}
}
catch (Exception ex)
{
var xlc = new ExceptionLogController();
xlc.AddLog(ex);
return("Failed");
}
return("Success");
}
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 DeleteExtensionPackage(PackageInfo package)
{
switch (package.PackageType)
{
case "Auth_System":
AuthenticationInfo authSystem = AuthenticationController.GetAuthenticationServiceByPackageID(package.PackageID);
if (authSystem != null)
{
AuthenticationController.DeleteAuthentication(authSystem);
}
break;
case "CoreLanguagePack":
LanguagePackInfo languagePack = LanguagePackController.GetLanguagePackByPackage(package.PackageID);
if (languagePack != null)
{
LanguagePackController.DeleteLanguagePack(languagePack);
}
break;
case "Module":
var controller = new DesktopModuleController();
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(package.PackageID);
if (desktopModule != null)
{
controller.DeleteDesktopModule(desktopModule);
}
break;
case "SkinObject":
SkinControlInfo skinControl = SkinControlController.GetSkinControlByPackageID(package.PackageID);
if (skinControl != null)
{
SkinControlController.DeleteSkinControl(skinControl);
}
break;
}
DeletePackageInternal(package);
}
public ModulePackageDetailDto(int portalId, PackageInfo package, DesktopModuleInfo desktopModule) : base(portalId, package)
{
DesktopModuleId = desktopModule.DesktopModuleID;
ModuleName = desktopModule.ModuleName;
FolderName = desktopModule.FolderName;
BusinessController = desktopModule.BusinessControllerClass;
Category = desktopModule.Category;
Dependencies = desktopModule.Dependencies;
HostPermissions = desktopModule.Permissions;
Portable = desktopModule.IsPortable;
Searchable = desktopModule.IsSearchable;
Upgradeable = desktopModule.IsUpgradeable;
PremiumModule = desktopModule.IsPremium;
Shareable = desktopModule.Shareable;
if (!desktopModule.IsAdmin)
{
var portalDesktopModules =
DesktopModuleController.GetPortalDesktopModulesByDesktopModuleID(desktopModule.DesktopModuleID);
foreach (var portalDesktopModuleInfo in portalDesktopModules)
{
var value = portalDesktopModuleInfo.Value;
AssignedPortals.Add(new ListItemDto {
Id = value.PortalID, Name = value.PortalName
});
}
var assignedIds = AssignedPortals.Select(p => p.Id).ToArray();
var allPortals = PortalController.Instance.GetPortals().OfType <PortalInfo>().Where(p => !assignedIds.Contains(p.PortalID));
foreach (var portalInfo in allPortals)
{
UnassignedPortals.Add(new ListItemDto {
Id = portalInfo.PortalID, Name = portalInfo.PortalName
});
}
}
foreach (var moduleDefinition in desktopModule.ModuleDefinitions.Values)
{
ModuleDefinitions.Add(new ModuleDefinitionDto(moduleDefinition));
}
}
private int GetModuleDefinitionID()
{
// get desktop module
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByModuleName("DotNetNuke.RadEditorProvider", Null.NullInteger);
if (desktopModule == null)
{
return(-1);
}
//get module definition
ModuleDefinitionInfo moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("RadEditor Manager", desktopModule.DesktopModuleID);
if (moduleDefinition == null)
{
return(-1);
}
return(moduleDefinition.ModuleDefID);
}
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);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The ReadManifest method reads the manifest file for the Module compoent.
/// </summary>
/// -----------------------------------------------------------------------------
public override void ReadManifest(XPathNavigator manifestNav)
{
// Load the Desktop Module from the manifest
this._desktopModule = CBO.DeserializeObject <DesktopModuleInfo>(new StringReader(manifestNav.InnerXml));
this._desktopModule.FriendlyName = this.Package.FriendlyName;
this._desktopModule.Description = this.Package.Description;
this._desktopModule.Version = Globals.FormatVersion(this.Package.Version, "00", 4, ".");
this._desktopModule.CompatibleVersions = Null.NullString;
this._desktopModule.Dependencies = Null.NullString;
this._desktopModule.Permissions = Null.NullString;
if (string.IsNullOrEmpty(this._desktopModule.BusinessControllerClass))
{
this._desktopModule.SupportedFeatures = 0;
}
this._eventMessage = this.ReadEventMessageNode(manifestNav);
// 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 = this._desktopModule.ModuleDefinitions[friendlyName];
if (moduleDefinition != null)
{
moduleDefinition.Permissions.Add(permission.PermissionKey, permission);
}
}
}
if (this.Log.Valid)
{
this.Log.AddInfo(Util.MODULE_ReadSuccess);
}
}
private void DeleteModule()
{
try
{
DesktopModuleInfo tempDesktopModule = DesktopModuleController.GetDesktopModuleByPackageID(Package.PackageID);
if (tempDesktopModule != null)
{
if ((DesktopModule != null) && (!string.IsNullOrEmpty(DesktopModule.CodeSubDirectory)))
{
Config.RemoveCodeSubDirectory(DesktopModule.CodeSubDirectory);
}
DesktopModuleController controller = new DesktopModuleController();
controller.DeleteDesktopModule(tempDesktopModule);
}
Log.AddInfo(string.Format(Util.MODULE_UnRegistered, tempDesktopModule.ModuleName));
}
catch (Exception ex)
{
Log.AddFailure(ex);
}
}
public override void Install()
{
try
{
InstalledDesktopModule = DesktopModuleController.GetDesktopModuleByModuleName(DesktopModule.ModuleName, Package.InstallerInfo.PortalID);
if (InstalledDesktopModule != null)
{
DesktopModule.DesktopModuleID = InstalledDesktopModule.DesktopModuleID;
}
DataCache.RemoveCache(DataCache.ModuleDefinitionCacheKey);
DataCache.RemoveCache(DataCache.ModuleControlsCacheKey);
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);
}
}
private ModuleApplication GetModuleApplication(DesktopModuleInfo desktopModule, RouteData defaultRouteData)
{
ModuleApplication moduleApplication = null;
// Check if the MVC Module overrides the base ModuleApplication class.
var businessControllerClass = desktopModule.BusinessControllerClass;
if (!string.IsNullOrEmpty(businessControllerClass))
{
var moduleApplicationType = Reflection.CreateType(businessControllerClass);
if (moduleApplicationType != null)
{
moduleApplication = Reflection.CreateInstance(moduleApplicationType) as ModuleApplication;
if (moduleApplication != null)
{
defaultRouteData.Values["controller"] = moduleApplication.DefaultControllerName;
defaultRouteData.Values["action"] = moduleApplication.DefaultActionName;
defaultRouteData.DataTokens["namespaces"] = moduleApplication.DefaultNamespaces;
}
}
}
if (moduleApplication == null)
{
var defaultControllerName = (string)defaultRouteData.Values["controller"];
var defaultActionName = (string)defaultRouteData.Values["action"];
var defaultNamespaces = (string[])defaultRouteData.DataTokens["namespaces"];
moduleApplication = new ModuleApplication
{
DefaultActionName = defaultControllerName,
DefaultControllerName = defaultActionName,
DefaultNamespaces = defaultNamespaces,
ModuleName = desktopModule.ModuleName,
FolderPath = desktopModule.FolderName,
};
}
return(moduleApplication);
}
/// <summary>Gets the module definition identifier.</summary>
/// <param name="moduleName">Name of the module.</param>
/// <param name="moduleDefinitionName">Name of the module definition.</param>
/// <returns>The Module Id for the HTML Editor Management module</returns>
private int GetModuleDefinitionID(string moduleName, string moduleDefinitionName)
{
// get desktop module
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByModuleName(moduleName, Null.NullInteger);
if (desktopModule == null)
{
return(-1);
}
// get module definition
ModuleDefinitionInfo moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByDefinitionName(
moduleDefinitionName,
desktopModule.DesktopModuleID);
if (moduleDefinition == null)
{
return(-1);
}
return(moduleDefinition.ModuleDefID);
}
private void DeleteProvider()
{
try
{
//Attempt to get the Desktop Module
//Attempt to get the Desktop Module
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(Package.PackageID);
ExtensionUrlProviderInfo tempUrlProvider = ExtensionUrlProviderController.GetProviders(Null.NullInteger)
.SingleOrDefault(p => p.DesktopModuleId == desktopModule.DesktopModuleID);
if (tempUrlProvider != null)
{
ExtensionUrlProviderController.DeleteProvider(tempUrlProvider);
Log.AddInfo(string.Format(Util.URLPROVIDER_UnRegistered, tempUrlProvider.ProviderName));
}
}
catch (Exception ex)
{
Log.AddFailure(ex);
}
}
/// <summary>
/// Check if the module has been activated somewhere
/// </summary>
/// <param name="dmi"></param>
/// <returns></returns>
public bool IsInPage(DesktopModuleInfo dmi)
{
PortalSettings portalSettings = new PortalSettings();
int portalId = portalSettings.PortalId;
TabController TC = new TabController();
foreach (TabInfo ti in TC.GetTabsByPortal(portalId).Values)
{
//We don't look for deleted pages
if (!ti.IsDeleted)
{
foreach (ModuleInfo mi in ti.ChildModules.Values)
{
if (mi.FriendlyName == dmi.FriendlyName && mi.DesktopModuleID == dmi.DesktopModuleID && !mi.IsDeleted /*The module is not activated if it is deleted*/)
{
return(true);
}
}
}
}
return(false);
}
public string UpgradeModule(string Version)
{
try
{
switch (Version)
{
case "01.00.00":
ModuleDefinitionInfo moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("Taxonomy Manager");
if (moduleDefinition != null)
{
//Add Module to Admin Page for all Portals
Upgrade.AddAdminPages("Taxonomy",
"Manage the Taxonomy for your Site",
"~/images/icon_tag_16px.gif",
"~/images/icon_tag_32px.gif",
true,
moduleDefinition.ModuleDefID,
"Taxonomy Manager",
"~/images/icon_tag_32px.gif",
true);
}
break;
case "06.00.00":
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByModuleName("DotNetNuke.Taxonomy", Null.NullInteger);
desktopModule.Category = "Admin";
DesktopModuleController.SaveDesktopModule(desktopModule, false, false);
break;
}
return("Success");
}
catch (Exception exc)
{
Logger.Error(exc);
return("Failed");
}
}
private static void AddClientResourceAdminHostPage()
{
DesktopModuleInfo desktopModule = DesktopModuleController.GetDesktopModuleByModuleName(Constants.ModuleName, Null.NullInteger);
ModuleDefinitionInfo moduleDefinition = desktopModule.ModuleDefinitions[Constants.ModuleDefinitionName];
// Remove the page if it already exists to ensure the page can be added.
// Handles cases where the page has been removed by the user.
try
{
Upgrade.RemoveHostPage(Localization.GetString("PageName", ResourceFileRelativePath));
}
catch
{
// Do nothing.
}
TabInfo hostPage = Upgrade.AddHostPage(Localization.GetString("PageName", ResourceFileRelativePath),
Localization.GetString("PageDescription", ResourceFileRelativePath),
Constants.ConfigIconFileThumbNail,
Constants.ConfigIconFileLarge, true);
Upgrade.AddModuleToPage(hostPage, moduleDefinition.ModuleDefID, Localization.GetString("ModuleTitle", ResourceFileRelativePath), Constants.ConfigIconFileLarge, true);
}
/// <summary>
/// 添加新的模块
/// </summary>
public Int32 AddNewModule(TabInfo CurrentTab)
{
//找到HTML模块的编号
int desktopModuleId = 0;
int ModuleId = 0;
DesktopModuleInfo deskModule = DesktopModuleController.GetDesktopModuleByModuleName("DNNGo.ThemePlugin", BSkin.PortalSettings.PortalId);
if (deskModule != null && deskModule.DesktopModuleID > 0)
{
desktopModuleId = deskModule.DesktopModuleID;
var list = TabModulesController.Instance.GetTabModules(new TabInfo()
{
TabID = CurrentTab.TabID
}).Cast <ModuleInfo>().ToList();
if (list != null && list.Count > 0)
{
ModuleInfo mInfo = list.Find(r => BSkin.ModuleProperty(r, "ModuleName") == "DNNGo.ThemePlugin");
if (!(mInfo != null && mInfo.ModuleID > 0))
{
ModuleId = AddNewModule("DNNGo ThemePlugin", desktopModuleId, CurrentTab, "ContentPane", -1, ViewPermissionType.View, "");
}
else
{
ModuleId = mInfo.ModuleID;
}
}
else
{
ModuleId = AddNewModule("DNNGo ThemePlugin", desktopModuleId, CurrentTab, "ContentPane", -1, ViewPermissionType.View, "");
}
}
return(ModuleId);
}
private static bool GetIsPortable(string moduleID, string tabID)
{
bool isPortable = false;
int parsedModuleID;
int parsedTabID;
bool validModuleID = int.TryParse(moduleID, out parsedModuleID);
bool validTabID = int.TryParse(tabID, out parsedTabID);
if (validModuleID && validTabID)
{
ModuleInfo moduleInfo = ModuleController.Instance.GetModule(parsedModuleID, parsedTabID, false);
if (moduleInfo != null)
{
DesktopModuleInfo moduleDesktopInfo = moduleInfo.DesktopModule;
if (moduleDesktopInfo != null)
{
isPortable = moduleDesktopInfo.IsPortable;
}
}
}
return(isPortable);
}
