/// -----------------------------------------------------------------------------
/// <summary>
/// DeleteDesktopModule deletes a Desktop Module
/// </summary>
/// <param name="moduleName">The Name of the Desktop Module to delete</param>
/// <history>
/// [cnurse] 05/14/2009 Documented
/// </history>
/// -----------------------------------------------------------------------------
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.DeletePackage(desktopModule.PackageID);
}
}
/// -----------------------------------------------------------------------------
/// <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>
/// RemoveCoreModule removes a Core Module from the system
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="desktopModuleName">The Friendly Name of the Module to Remove</param>
/// <param name="parentTabName">The Name of the parent Tab/Page for this module</param>
/// <param name="tabName">The Name to tab that contains the Module</param>
/// <param name="removeTab">A flag to determine whether to remove the Tab if it has no
/// other modules</param>
/// <history>
/// [cnurse] 10/14/2004 documented
/// </history>
/// -----------------------------------------------------------------------------
private static void RemoveCoreModule(string desktopModuleName, string parentTabName, string tabName, bool removeTab)
{
DnnInstallLogger.InstallLogInfo(Localization.Localization.GetString("LogStart", Localization.Localization.GlobalResourceFile) + "RemoveCoreModule:" + desktopModuleName);
int moduleDefId = Null.NullInteger;
int desktopModuleId = 0;
//Find and remove the Module from the Tab
switch (parentTabName)
{
case "Host":
var tab = TabController.Instance.GetTabByName("Host", Null.NullInteger, Null.NullInteger);
if (tab != null)
{
moduleDefId = RemoveModule(desktopModuleName, tabName, tab.TabID, removeTab);
}
break;
case "Admin":
var portals = PortalController.Instance.GetPortals();
//Iterate through the Portals to remove the Module from the Tab
for (int intPortal = 0; intPortal <= portals.Count - 1; intPortal++)
{
var portal = (PortalInfo)portals[intPortal];
moduleDefId = RemoveModule(desktopModuleName, tabName, portal.AdminTabId, removeTab);
}
break;
}
DesktopModuleInfo desktopModule = null;
if (moduleDefId == Null.NullInteger)
{
desktopModule = DesktopModuleController.GetDesktopModuleByModuleName(desktopModuleName, Null.NullInteger);
desktopModuleId = desktopModule.DesktopModuleID;
}
else
{
//Get the Module Definition
ModuleDefinitionInfo moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByID(moduleDefId);
if (moduleDefinition != null)
{
desktopModuleId = moduleDefinition.DesktopModuleID;
desktopModule = DesktopModuleController.GetDesktopModule(desktopModuleId, Null.NullInteger);
}
}
if (desktopModule != null)
{
//Delete the Desktop Module
var desktopModuleController = new DesktopModuleController();
desktopModuleController.DeleteDesktopModule(desktopModuleId);
//Delete the Package
PackageController.Instance.DeleteExtensionPackage(PackageController.Instance.GetExtensionPackage(Null.NullInteger, p => p.PackageID == desktopModule.PackageID));
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// The DeleteModule method deletes the Module from the data Store.
/// </summary>
/// <history>
/// [cnurse] 01/15/2008 created
/// </history>
/// -----------------------------------------------------------------------------
private void DeleteModule()
{
try
{
//Attempt to get the Desktop Module
DesktopModuleInfo tempDesktopModule = DesktopModuleController.GetDesktopModuleByPackageID(Package.PackageID);
if (tempDesktopModule != null)
{
//Remove CodeSubDirectory
if ((_desktopModule != null) && (!string.IsNullOrEmpty(_desktopModule.CodeSubDirectory)))
{
Config.RemoveCodeSubDirectory(_desktopModule.CodeSubDirectory);
}
var controller = new DesktopModuleController();
controller.DeleteDesktopModule(tempDesktopModule);
Log.AddInfo(string.Format(Util.MODULE_UnRegistered, tempDesktopModule.ModuleName));
}
}
catch (Exception ex)
{
Log.AddFailure(ex);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// DeleteDesktopModule deletes a Desktop Module
/// </summary>
/// <param name="moduleName">The Name of the Desktop Module to delete</param>
/// <history>
/// [cnurse] 05/14/2009 Documented
/// </history>
/// -----------------------------------------------------------------------------
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.DeletePackage(desktopModule.PackageID);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// DeleteDesktopModule deletes a Desktop Module
/// </summary>
/// <param name="moduleName">The Name of the Desktop Module to delete</param>
/// <history>
/// [cnurse] 05/14/2009 Documented
/// </history>
/// -----------------------------------------------------------------------------
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>
/// RemoveCoreModule removes a Core Module from the system
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="DesktopModuleName">The Friendly Name of the Module to Remove</param>
/// <param name="ParentTabName">The Name of the parent Tab/Page for this module</param>
/// <param name="TabName">The Name to tab that contains the Module</param>
/// <param name="TabRemove">A flag to determine whether to remove the Tab if it has no
/// other modules</param>
private static void RemoveCoreModule(string DesktopModuleName, string ParentTabName, string TabName, bool TabRemove)
{
TabController objTabs = new TabController();
ModuleController objModules = new ModuleController();
int intIndex;
int intModuleDefId = 0;
int intDesktopModuleId;
//Find and remove the Module from the Tab
switch (ParentTabName)
{
case "Host":
//TODO - when we have a need to remove a Host Module
break;
case "Admin":
PortalController objPortals = new PortalController();
ArrayList arrPortals = objPortals.GetPortals();
//Iterate through the Portals to remove the Module from the Tab
for (int intPortal = 0; intPortal < arrPortals.Count; intPortal++)
{
PortalInfo objPortal = (PortalInfo)(arrPortals[intPortal]);
int ParentId = objPortal.AdminTabId;
TabInfo objTab = objTabs.GetTabByName(TabName, objPortal.PortalID, ParentId);
int intCount = 0;
//Get the Modules on the Tab
foreach (KeyValuePair<int, ModuleInfo> kvp in objModules.GetTabModules(objTab.TabID))
{
ModuleInfo objModule = kvp.Value;
if (objModule.FriendlyName == DesktopModuleName)
{
//Delete the Module from the Modules list
objModules.DeleteModule(objModule.ModuleID);
intModuleDefId = objModule.ModuleDefID;
}
else
{
intCount += 1;
}
}
//If Tab has no modules optionally remove tab
if (intCount == 0 & TabRemove)
{
objTabs.DeleteTab(objTab.TabID, objTab.PortalID);
}
}
break;
}
//Delete all the Module Controls for this Definition
ModuleControlController objModuleControls = new ModuleControlController();
ArrayList arrModuleControls = objModuleControls.GetModuleControls(intModuleDefId);
for (intIndex = 0; intIndex <= arrModuleControls.Count - 1; intIndex++)
{
ModuleControlInfo objModuleControl = (ModuleControlInfo)arrModuleControls[intIndex];
objModuleControls.DeleteModuleControl(objModuleControl.ModuleControlID);
}
//Get the Module Definition
ModuleDefinitionController objModuleDefinitions = new ModuleDefinitionController();
ModuleDefinitionInfo objModuleDefinition;
objModuleDefinition = objModuleDefinitions.GetModuleDefinition(intModuleDefId);
intDesktopModuleId = objModuleDefinition.DesktopModuleID;
//Delete the Module Definition
objModuleDefinitions.DeleteModuleDefinition(intModuleDefId);
//Delete the Desktop Module Control
DesktopModuleController objDesktopModules = new DesktopModuleController();
objDesktopModules.DeleteDesktopModule(intDesktopModuleId);
}
/// <summary>
/// cmdDelete_Click runs when the Delete Button is clicked
/// </summary>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void cmdDelete_Click( object sender, EventArgs e )
{
try
{
if( ! Null.IsNull( DesktopModuleId ) )
{
string strRoot = Request.MapPath( "~/DesktopModules/" + txtFolderName.Text ) + "\\";
// process uninstall script
string strProviderType = "data";
ProviderConfiguration objProviderConfiguration = ProviderConfiguration.GetProviderConfiguration( strProviderType );
string strUninstallScript = "Uninstall." + objProviderConfiguration.DefaultProvider;
if( File.Exists( strRoot + strUninstallScript ) )
{
// read uninstall script
StreamReader objStreamReader;
objStreamReader = File.OpenText( strRoot + strUninstallScript );
string strScript = objStreamReader.ReadToEnd();
objStreamReader.Close();
// execute uninstall script
PortalSettings.ExecuteScript( strScript );
}
if( Directory.Exists( strRoot ) )
{
if( chkDelete.Checked )
{
//runtime so remove files/folders
// find dnn manifest file
string[] arrFiles = Directory.GetFiles( strRoot, "*.dnn.config" );
if( arrFiles.Length == 0 )
{
arrFiles = Directory.GetFiles( strRoot, "*.dnn" ); // legacy versions stored the *.dnn files unprotected
}
if( arrFiles.Length != 0 )
{
if( File.Exists( strRoot + Path.GetFileName( arrFiles[0] ) ) )
{
XmlDocument xmlDoc = new XmlDocument();
// load the manifest file
xmlDoc.Load( strRoot + Path.GetFileName( arrFiles[0] ) );
// check version
XmlNode myNodeModule = null;
switch( xmlDoc.DocumentElement.LocalName.ToLower() )
{
case "module":
myNodeModule = xmlDoc.SelectSingleNode("//module");
break;
case "dotnetnuke":
string version = xmlDoc.DocumentElement.Attributes["version"].InnerText;
switch( version )
{
case "2.0":
// V2 allows for multiple folders in a single DNN definition - we need to identify the correct node
foreach( XmlNode nodeModule in xmlDoc.SelectNodes( "//dotnetnuke/folders/folder" ) )
{
if( nodeModule.SelectSingleNode( "name" ).InnerText.Trim() == txtFriendlyName.Text )
{
myNodeModule = nodeModule;
break;
}
}
break;
case "3.0":
// V3 also allows for multiple folders in a single DNN definition - but uses module name
foreach( XmlNode nodeModule in xmlDoc.SelectNodes( "//dotnetnuke/folders/folder" ) )
{
if( nodeModule.SelectSingleNode( "name" ).InnerText.Trim() == txtModuleName.Text )
{
myNodeModule = nodeModule;
break;
}
}
break;
}
break;
}
// loop through file nodes
foreach (XmlNode nodeFile in myNodeModule.SelectNodes("files/file"))
{
string strFileName = nodeFile.SelectSingleNode( "name" ).InnerText.Trim();
string strFileExtension = Path.GetExtension( strFileName ).Replace( ".", "" );
if( strFileExtension == "dll" )
{
// remove DLL from /bin
strFileName = Request.MapPath( "~/bin/" ) + strFileName;
}
if( File.Exists( strFileName ) )
{
File.SetAttributes( strFileName, FileAttributes.Normal );
File.Delete( strFileName );
}
}
//Recursively Delete any sub Folders
DeleteSubFolders( strRoot, true );
//Recursively delete AppCode folders
string appCode = strRoot.Replace( "DesktopModules", "App_Code" );
DeleteSubFolders( appCode, true );
//Delete the <codeSubDirectory> node in web.config
Config.RemoveCodeSubDirectory( txtFolderName.Text );
}
}
}
}
// delete the desktopmodule database record
DesktopModuleController objDesktopModules = new DesktopModuleController();
objDesktopModules.DeleteDesktopModule( DesktopModuleId );
}
Response.Redirect( Globals.NavigateURL(), true );
}
catch( Exception exc ) //Module failed to load
{
Exceptions.ProcessModuleLoadException( this, exc );
}
}
public static void DeletePackage(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;
}
DeletePackage(package.PackageID);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// RemoveCoreModule removes a Core Module from the system
/// </summary>
/// <remarks>
/// </remarks>
/// <param name="desktopModuleName">The Friendly Name of the Module to Remove</param>
/// <param name="parentTabName">The Name of the parent Tab/Page for this module</param>
/// <param name="tabName">The Name to tab that contains the Module</param>
/// <param name="removeTab">A flag to determine whether to remove the Tab if it has no
/// other modules</param>
/// <history>
/// [cnurse] 10/14/2004 documented
/// </history>
/// -----------------------------------------------------------------------------
private static void RemoveCoreModule(string desktopModuleName, string parentTabName, string tabName, bool removeTab)
{
int moduleDefId = Null.NullInteger;
int desktopModuleId = 0;
//Find and remove the Module from the Tab
switch (parentTabName)
{
case "Host":
var tabController = new TabController();
var tab = tabController.GetTabByName("Host", Null.NullInteger, Null.NullInteger);
if (tab != null)
{
moduleDefId = RemoveModule(desktopModuleName, tabName, tab.TabID, removeTab);
}
break;
case "Admin":
var portalController = new PortalController();
PortalInfo portal;
var portals = portalController.GetPortals();
//Iterate through the Portals to remove the Module from the Tab
for (int intPortal = 0; intPortal <= portals.Count - 1; intPortal++)
{
portal = (PortalInfo) portals[intPortal];
moduleDefId = RemoveModule(desktopModuleName, tabName, portal.AdminTabId, removeTab);
}
break;
}
DesktopModuleInfo desktopModule = null;
if (moduleDefId == Null.NullInteger)
{
desktopModule = DesktopModuleController.GetDesktopModuleByModuleName(desktopModuleName, Null.NullInteger);
desktopModuleId = desktopModule.DesktopModuleID;
}
else
{
//Get the Module Definition
ModuleDefinitionInfo moduleDefinition = ModuleDefinitionController.GetModuleDefinitionByID(moduleDefId);
if (moduleDefinition != null)
{
desktopModuleId = moduleDefinition.DesktopModuleID;
desktopModule = DesktopModuleController.GetDesktopModule(desktopModuleId, Null.NullInteger);
}
}
if (desktopModule != null)
{
//Delete the Desktop Module
var desktopModuleController = new DesktopModuleController();
desktopModuleController.DeleteDesktopModule(desktopModuleId);
//Delete the Package
PackageController.DeletePackage(desktopModule.PackageID);
}
}