/// <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);
}
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);
}
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>
/// 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);
}
/// -----------------------------------------------------------------------------
/// <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;
}
public void UpdateDesktopModule(DesktopModuleInfo objDesktopModule)
{
SaveDesktopModule(objDesktopModule, false, true);
}
