/// <summary>
/// LoadCacheProperties loads the Module Definitions Default Cache Time properties
/// </summary>
/// <history>
/// [cnurse] 4/21/2005 created
/// </history>
private void LoadCacheProperties(int ModuleDefId)
{
ModuleDefinitionController objModuleDefinitionController = new ModuleDefinitionController();
ModuleDefinitionInfo objModuleDefinition = objModuleDefinitionController.GetModuleDefinition(ModuleDefId);
txtCacheTime.Text = objModuleDefinition.DefaultCacheTime.ToString();
}
/// <inheritdoc cref="IViewManager.SaveModuleNavigationAsync(ModuleNavigationInfo)" />
public async Task <bool> SaveModuleNavigationAsync(ModuleNavigationInfo moduleNavigation)
{
if (moduleNavigation is null)
{
return(false);
}
ModuleDefinitionInfo moduleDef = await GetModuleDefAsync(moduleNavigation.ModuleDefinitionId);
if (moduleDef is null)
{
return(false);
}
ModuleNavigation navigation = moduleNavigation.Id > 0 ?
await _dbContext.KastraModuleNavigations.SingleOrDefaultAsync(mn => mn.Id == moduleNavigation.Id) : null;
navigation = moduleNavigation.ToModuleNavigation();
if (navigation.Id > 0)
{
_dbContext.KastraModuleNavigations.Update(navigation);
}
else
{
_dbContext.KastraModuleNavigations.Add(navigation);
}
await _dbContext.SaveChangesAsync();
// Clear cache
_cacheEngine.ClearCacheContains("Module");
return(true);
}
/// <inheritdoc cref="IViewManager.SaveModuleControlAsync(ModuleControlInfo)" />
public async Task <bool> SaveModuleControlAsync(ModuleControlInfo moduleControlInfo)
{
if (moduleControlInfo is null)
{
return(false);
}
ModuleControl moduleControl = await _dbContext.KastraModuleControls
.SingleOrDefaultAsync(mc => mc.ModuleControlId == moduleControlInfo.ModuleControlId);
ModuleDefinitionInfo moduleDef = await GetModuleDefAsync(moduleControlInfo.ModuleDefId);
if (moduleDef is null)
{
return(false);
}
moduleControl = moduleControlInfo.ToModuleControl();
if (moduleControl.ModuleControlId > 0)
{
_dbContext.KastraModuleControls.Update(moduleControl);
}
else
{
_dbContext.KastraModuleControls.Add(moduleControl);
}
await _dbContext.SaveChangesAsync();
// Clear cache
_cacheEngine.ClearCacheContains("Module");
return(true);
}
/// <inheritdoc cref="IViewManager.SaveModuleDefAsync(ModuleDefinitionInfo)" />
public async Task <bool> SaveModuleDefAsync(ModuleDefinitionInfo moduleDefinition)
{
ModuleDefinition newModuleDefinition;
if (moduleDefinition is null)
{
return(false);
}
newModuleDefinition = moduleDefinition.ToModuleDefinition();
if (newModuleDefinition.ModuleDefId > 0)
{
_dbContext.KastraModuleDefinitions.Update(newModuleDefinition);
}
else
{
_dbContext.KastraModuleDefinitions.Add(newModuleDefinition);
}
await _dbContext.SaveChangesAsync();
// Clear cache
_cacheEngine.ClearCacheContains("Module");
return(true);
}
protected virtual ModuleDefinitionInfo GetModuleFromNode(int TempModuleDefinitionID, PaFolder Folder, XmlElement DNNModule)
{
ModuleDefinitionInfo ModuleDef = new ModuleDefinitionInfo();
XmlElement friendlyNameElement = (XmlElement)DNNModule.SelectSingleNode("friendlyname");
if (friendlyNameElement != null)
{
ModuleDef.FriendlyName = friendlyNameElement.InnerText.Trim();
}
ModuleDef.TempModuleID = TempModuleDefinitionID;
//We need to ensure that admin order is null for "User" modules
InstallerInfo.Log.AddInfo(string.Format(MODULES_ControlInfo, ModuleDef.FriendlyName));
XmlElement ModuleControl;
foreach (XmlElement tempLoopVar_ModuleControl in DNNModule.SelectNodes("controls/control"))
{
ModuleControl = tempLoopVar_ModuleControl;
Folder.Controls.Add(GetModuleControlFromNode(Folder.Name, ModuleDef.TempModuleID, ModuleControl));
}
return(ModuleDef);
}
public static ModuleDefinitionModel ToModuleDefinitionModel(ModuleDefinitionInfo moduleDefinitionInfo)
{
ModuleDefinitionModel model = new ModuleDefinitionModel();
model.Id = moduleDefinitionInfo.ModuleDefId;
model.Name = moduleDefinitionInfo.Name;
return(model);
}
protected void grdControls_DeleteCommand(object source, DataGridCommandEventArgs e)
{
int controlID = Int32.Parse(e.CommandArgument.ToString());
ModuleControlController.DeleteModuleControl(controlID);
//Force Module Definition to refresh
_ModuleDefinition = null;
BindDefinition();
}
/// <summary>
/// cmdAddDefinition_Click runs when the Add Definition Button is clicked
/// </summary>
/// <history>
/// [cnurse] 9/28/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
protected void cmdAddDefinition_Click(object sender, EventArgs e)
{
if (!String.IsNullOrEmpty(txtDefinition.Text))
{
ModuleDefinitionInfo objModuleDefinition = new ModuleDefinitionInfo();
objModuleDefinition.DesktopModuleID = DesktopModuleId;
objModuleDefinition.FriendlyName = txtDefinition.Text;
try
{
objModuleDefinition.DefaultCacheTime = int.Parse(txtCacheTime.Text);
if (objModuleDefinition.DefaultCacheTime < 0)
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("UpdateCache.ErrorMessage", this.LocalResourceFile), ModuleMessageType.RedError);
return;
}
}
catch
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("UpdateCache.ErrorMessage", this.LocalResourceFile), ModuleMessageType.RedError);
return;
}
ModuleDefinitionController objModuleDefinitions = new ModuleDefinitionController();
int ModuleDefId;
try
{
ModuleDefId = objModuleDefinitions.AddModuleDefinition(objModuleDefinition);
}
catch
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("AddDefinition.ErrorMessage", this.LocalResourceFile), ModuleMessageType.RedError);
return;
}
LoadDefinitions();
if (ModuleDefId > -1)
{
//Set the Combo
cboDefinitions.SelectedIndex = -1;
cboDefinitions.Items.FindByValue(ModuleDefId.ToString()).Selected = true;
LoadCacheProperties(ModuleDefId);
LoadControls(ModuleDefId);
//Clear the Text Box
txtDefinition.Text = "";
}
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("MissingDefinition.ErrorMessage", this.LocalResourceFile), ModuleMessageType.RedError);
}
}
private void ReadModuleDefinitions(XmlReader reader)
{
reader.ReadStartElement("moduleDefinitions");
do
{
reader.ReadStartElement("moduleDefinition");
ModuleDefinitionInfo moduleDefinition = new ModuleDefinitionInfo();
moduleDefinition.ReadXml(reader);
ModuleDefinitions.Add(moduleDefinition.FriendlyName, moduleDefinition);
} while (reader.ReadToNextSibling("moduleDefinition"));
}
/// -----------------------------------------------------------------------------
/// <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);
}
}
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);
}
}
private void BindDefinition()
{
if (IsAddDefinitionMode)
{
var definition = new ModuleDefinitionInfo {
DesktopModuleID = DesktopModule.DesktopModuleID, ModuleDefID = Null.NullInteger
};
definitionsEditor.DataSource = definition;
definitionsEditor.DataBind();
cmdDeleteDefinition.Visible = false;
cmdUpdateDefinition.Text = Localization.GetString("cmdCreateDefinition", LocalResourceFile);
cmdCancelDefinition.Visible = true;
pnlDefinition.Visible = true;
pnlControls.Visible = false;
definitionSelectRow.Visible = false;
definitionName.Visible = true;
definitionNameLiteral.Visible = false;
}
else
{
if (ModuleDefinition != null && ModuleDefinition.DesktopModuleID == DesktopModule.DesktopModuleID)
{
definitionsEditor.DataSource = ModuleDefinition;
definitionsEditor.DataBind();
cmdDeleteDefinition.Visible = true;
cmdUpdateDefinition.Text = Localization.GetString("cmdUpdateDefinition", LocalResourceFile);
if (!Page.IsPostBack)
{
Localization.LocalizeDataGrid(ref grdControls, LocalResourceFile);
}
grdControls.DataSource = ModuleDefinition.ModuleControls.Values;
grdControls.DataBind();
pnlDefinition.Visible = true;
pnlControls.Visible = true;
definitionSelectRow.Visible = true;
definitionName.Visible = false;
definitionNameLiteral.Visible = true;
cmdAddControl.NavigateUrl = ModuleContext.EditUrl("ModuleControlID", "-1", "EditControl", "packageId=" + PackageID, "moduledefid=" + ModuleDefinition.ModuleDefID);
}
else
{
pnlDefinition.Visible = false;
}
}
}
public ModuleDefinitionDto(ModuleDefinitionInfo definition)
{
Id = definition.ModuleDefID;
DesktopModuleId = definition.DesktopModuleID;
Name = definition.DefinitionName;
FriendlyName = definition.FriendlyName;
CacheTime = definition.DefaultCacheTime;
foreach (var moduleControlInfo in definition.ModuleControls.Values)
{
Controls.Add(new ModuleControlDto(moduleControlInfo));
}
}
protected void cmdAddDefinition_Click(object sender, EventArgs e)
{
IsAddDefinitionMode = true;
ModuleDefinitionID = Null.NullInteger;
_ModuleDefinition = null;
////empty definition form's content
definitionsEditor.Items.ForEach(i =>
{
i.Value = null;
});
BindDefinition();
}
public string UpgradeModule(string version)
{
try
{
switch (version)
{
case "07.01.00":
ModuleDefinitionInfo mDef = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("Digital Asset Management");
// Add tab to Admin Menu
if (mDef != null)
{
var hostPage = Upgrade.AddHostPage(
"File Management",
"Manage assets.",
"~/Icons/Sigma/Files_16X16_Standard.png",
"~/Icons/Sigma/Files_32X32_Standard.png",
true);
// Add module to page
Upgrade.AddModuleToPage(hostPage, mDef.ModuleDefID, "File Management", "~/Icons/Sigma/Files_32X32_Standard.png", true);
Upgrade.AddAdminPages(
"File Management",
"Manage assets within the portal",
"~/Icons/Sigma/Files_16X16_Standard.png",
"~/Icons/Sigma/Files_32X32_Standard.png",
true,
mDef.ModuleDefID,
"File Management",
"~/Icons/Sigma/Files_16X16_Standard.png",
true);
}
// Remove Host File Manager page
Upgrade.RemoveHostPage("File Manager");
// Remove Admin File Manager Pages
Upgrade.RemoveAdminPages("//Admin//FileManager");
break;
}
return("Success");
}
catch (Exception)
{
return("Failed");
}
}
protected override ModuleDefinitionInfo GetModuleFromNode(int TempModuleDefinitionID, PaFolder Folder, XmlElement DNNModule)
{
ModuleDefinitionInfo ModuleDef = base.GetModuleFromNode(TempModuleDefinitionID, Folder, DNNModule);
if (ModuleDef != null)
{
XmlElement cacheElement = (XmlElement)DNNModule.SelectSingleNode("cachetime");
if (cacheElement != null)
{
ModuleDef.DefaultCacheTime = Convert.ToInt32(cacheElement.InnerText.Trim());
}
}
return(ModuleDef);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// ExportModule implements the IPortable ExportModule Interface
/// </summary>
/// <param name="ModuleID">The Id of the module to be exported</param>
/// -----------------------------------------------------------------------------
//public string ExportModule(int ModuleID)
//{
//string strXML = "";
//List<OpenBlocksInfo> colOpenBlockss = GetOpenBlockss(ModuleID);
//if (colOpenBlockss.Count != 0)
//{
// strXML += "<OpenBlockss>";
// foreach (OpenBlocksInfo objOpenBlocks in colOpenBlockss)
// {
// strXML += "<OpenBlocks>";
// strXML += "<content>" + DotNetNuke.Common.Utilities.XmlUtils.XMLEncode(objOpenBlocks.Content) + "</content>";
// strXML += "</OpenBlocks>";
// }
// strXML += "</OpenBlockss>";
//}
//return strXML;
// throw new System.NotImplementedException("The method or operation is not implemented.");
//}
/// -----------------------------------------------------------------------------
/// <summary>
/// ImportModule implements the IPortable ImportModule Interface
/// </summary>
/// <param name="ModuleID">The Id of the module to be imported</param>
/// <param name="Content">The content to be imported</param>
/// <param name="Version">The version of the module to be imported</param>
/// <param name="UserId">The Id of the user performing the import</param>
/// -----------------------------------------------------------------------------
//public void ImportModule(int ModuleID, string Content, string Version, int UserID)
//{
//XmlNode xmlOpenBlockss = DotNetNuke.Common.Globals.GetContent(Content, "OpenBlockss");
//foreach (XmlNode xmlOpenBlocks in xmlOpenBlockss.SelectNodes("OpenBlocks"))
//{
// OpenBlocksInfo objOpenBlocks = new OpenBlocksInfo();
// objOpenBlocks.ModuleId = ModuleID;
// objOpenBlocks.Content = xmlOpenBlocks.SelectSingleNode("content").InnerText;
// objOpenBlocks.CreatedByUser = UserID;
// AddOpenBlocks(objOpenBlocks);
//}
// throw new System.NotImplementedException("The method or operation is not implemented.");
//}
/// -----------------------------------------------------------------------------
/// <summary>
/// GetSearchItems implements the ISearchable Interface
/// </summary>
/// <param name="ModInfo">The ModuleInfo for the module to be Indexed</param>
/// -----------------------------------------------------------------------------
//public DotNetNuke.Services.Search.SearchItemInfoCollection GetSearchItems(DotNetNuke.Entities.Modules.ModuleInfo ModInfo)
//{
//SearchItemInfoCollection SearchItemCollection = new SearchItemInfoCollection();
//List<OpenBlocksInfo> colOpenBlockss = GetOpenBlockss(ModInfo.ModuleID);
//foreach (OpenBlocksInfo objOpenBlocks in colOpenBlockss)
//{
// SearchItemInfo SearchItem = new SearchItemInfo(ModInfo.ModuleTitle, objOpenBlocks.Content, objOpenBlocks.CreatedByUser, objOpenBlocks.CreatedDate, ModInfo.ModuleID, objOpenBlocks.ItemId.ToString(), objOpenBlocks.Content, "ItemId=" + objOpenBlocks.ItemId.ToString());
// SearchItemCollection.Add(SearchItem);
//}
//return SearchItemCollection;
// throw new System.NotImplementedException("The method or operation is not implemented.");
//}
/// -----------------------------------------------------------------------------
/// <summary>
/// UpgradeModule implements the IUpgradeable Interface
/// </summary>
/// <param name="Version">The current version of the module</param>
/// -----------------------------------------------------------------------------
public string UpgradeModule(string Version)
{
string result = "";
try
{
switch (Version)
{
case "00.00.01":
ModuleDefinitionInfo mDef = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("OpenTemplateStudio");
//Add tab to Admin Menu
if (mDef != null)
{
var hostPage = Upgrade.AddHostPage("Template Studio",
"Open Template Studio",
"~/DesktopModules/OpenBlocks/Files_16X16_Standard.png",
"~/Icons/Sigma/Files_32X32_Standard.png",
true);
//Add module to page
Upgrade.AddModuleToPage(hostPage, mDef.ModuleDefID, "Open Template Studio", "~/Icons/Sigma/Files_32X32_Standard.png", true);
/*
* Upgrade.AddAdminPages("File Management",
* "Manage assets within the portal",
* "~/Icons/Sigma/Files_16X16_Standard.png",
* "~/Icons/Sigma/Files_32X32_Standard.png",
* true,
* mDef.ModuleDefID,
* "File Management",
* "~/Icons/Sigma/Files_16X16_Standard.png",
* true);
*/
result = hostPage == null ? "host page null" : "host page created";
}
break;
}
return("Success : " + result);
}
catch (Exception)
{
return("Failed");
}
}
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);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// ExportModule implements the IPortable ExportModule Interface
/// </summary>
/// <param name="ModuleID">The Id of the module to be exported</param>
/// -----------------------------------------------------------------------------
//public string ExportModule(int ModuleID)
//{
//string strXML = "";
//List<OpenBlocksInfo> colOpenBlockss = GetOpenBlockss(ModuleID);
//if (colOpenBlockss.Count != 0)
//{
// strXML += "<OpenBlockss>";
// foreach (OpenBlocksInfo objOpenBlocks in colOpenBlockss)
// {
// strXML += "<OpenBlocks>";
// strXML += "<content>" + DotNetNuke.Common.Utilities.XmlUtils.XMLEncode(objOpenBlocks.Content) + "</content>";
// strXML += "</OpenBlocks>";
// }
// strXML += "</OpenBlockss>";
//}
//return strXML;
// throw new System.NotImplementedException("The method or operation is not implemented.");
//}
/// -----------------------------------------------------------------------------
/// <summary>
/// ImportModule implements the IPortable ImportModule Interface
/// </summary>
/// <param name="ModuleID">The Id of the module to be imported</param>
/// <param name="Content">The content to be imported</param>
/// <param name="Version">The version of the module to be imported</param>
/// <param name="UserId">The Id of the user performing the import</param>
/// -----------------------------------------------------------------------------
//public void ImportModule(int ModuleID, string Content, string Version, int UserID)
//{
//XmlNode xmlOpenBlockss = DotNetNuke.Common.Globals.GetContent(Content, "OpenBlockss");
//foreach (XmlNode xmlOpenBlocks in xmlOpenBlockss.SelectNodes("OpenBlocks"))
//{
// OpenBlocksInfo objOpenBlocks = new OpenBlocksInfo();
// objOpenBlocks.ModuleId = ModuleID;
// objOpenBlocks.Content = xmlOpenBlocks.SelectSingleNode("content").InnerText;
// objOpenBlocks.CreatedByUser = UserID;
// AddOpenBlocks(objOpenBlocks);
//}
// throw new System.NotImplementedException("The method or operation is not implemented.");
//}
/// -----------------------------------------------------------------------------
/// <summary>
/// GetSearchItems implements the ISearchable Interface
/// </summary>
/// <param name="ModInfo">The ModuleInfo for the module to be Indexed</param>
/// -----------------------------------------------------------------------------
//public DotNetNuke.Services.Search.SearchItemInfoCollection GetSearchItems(DotNetNuke.Entities.Modules.ModuleInfo ModInfo)
//{
//SearchItemInfoCollection SearchItemCollection = new SearchItemInfoCollection();
//List<OpenBlocksInfo> colOpenBlockss = GetOpenBlockss(ModInfo.ModuleID);
//foreach (OpenBlocksInfo objOpenBlocks in colOpenBlockss)
//{
// SearchItemInfo SearchItem = new SearchItemInfo(ModInfo.ModuleTitle, objOpenBlocks.Content, objOpenBlocks.CreatedByUser, objOpenBlocks.CreatedDate, ModInfo.ModuleID, objOpenBlocks.ItemId.ToString(), objOpenBlocks.Content, "ItemId=" + objOpenBlocks.ItemId.ToString());
// SearchItemCollection.Add(SearchItem);
//}
//return SearchItemCollection;
// throw new System.NotImplementedException("The method or operation is not implemented.");
//}
/// -----------------------------------------------------------------------------
/// <summary>
/// UpgradeModule implements the IUpgradeable Interface
/// </summary>
/// <param name="Version">The current version of the module</param>
/// -----------------------------------------------------------------------------
public string UpgradeModule(string Version)
{
string result = "";
try
{
switch (Version)
{
case "00.00.01":
ModuleDefinitionInfo mDef = ModuleDefinitionController.GetModuleDefinitionByFriendlyName("OpenBlocks");
//Add tab to Admin Menu
if (mDef != null)
{
/*
* var hostPage = Upgrade.AddHostPage("Open Blocks",
* "Open Blocks",
* "~/Icons/Sigma/Software_16X16_Standard.png",
* "~/Icons/Sigma/Software_32X32_Standard.png",
* true);
*
* //Add module to page
* Upgrade.AddModuleToPage(hostPage, mDef.ModuleDefID, "Open Blocks", "~/Icons/Sigma/Software_32X32_Standard.png", true);
*/
AddAdminPages("Blocks",
"Manage resuable blocks of content",
"~/Icons/Sigma/Software_16X16_Standard.png",
"~/Icons/Sigma/Software_32X32_Standard.png",
true,
mDef.ModuleDefID,
"Open Blocks",
"~/Icons/Sigma/Software_16X16_Standard.png",
true);
//result = hostPage == null ? "hostpage null" : "hostpage created";
}
break;
}
return("Success " + result);
}
catch (Exception)
{
return("Failed");
}
}
protected void cboDefinitions_SelectedIndexChanged(object sender, EventArgs e)
{
if (!IsAddDefinitionMode)
{
ModuleDefinitionID = int.Parse(cboDefinitions.SelectedValue);
//Force Module Definition to refresh
_ModuleDefinition = null;
//empty definition form's content
definitionsEditor.Items.ForEach(i =>
{
i.Value = null;
});
BindDefinition();
}
}
public static void SoftDeleteModule(int PortalId, string ModuleFriendlyName)
{
try
{
using (VanjaroRepo vrepo = new VanjaroRepo())
{
ModuleDefinitionInfo moduleDefinitionInfo = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(ModuleFriendlyName);
System.Collections.Generic.List <ModuleSettings> moduleInfo = vrepo.Fetch <ModuleSettings>("Select T.PortalID,Tabm.TabID,Tabm.ModuleID,Tabm.PaneName,Tabm.IsDeleted from TabModules Tabm inner join Tabs T On Tabm.TabID = t.TabID Where PortalID=@0 AND ModuleTitle= @1", PortalId, ModuleFriendlyName);
foreach (ModuleSettings ModuleSettings in moduleInfo)
{
ModuleController.Instance.DeleteTabModule(ModuleSettings.TabID, ModuleSettings.ModuleID, true);
}
}
}
catch (Exception) { }
}
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);
}
}
static ModuleDefinitionInfo GetModuleDefinition(XmlNode nodeModule)
{
ModuleDefinitionInfo objModuleDefinition = null;
// Templates prior to v4.3.5 only have the <definition> node to define the Module Type
// This <definition> node was populated with the DesktopModuleInfo.ModuleName property
// Thus there is no mechanism to determine to which module definition the module belongs.
//
// Template from v4.3.5 on also have the <moduledefinition> element that is populated
// with the ModuleDefinitionInfo.FriendlyName. Therefore the module Instance identifies
// which Module Definition it belongs to.
//Get the DesktopModule defined by the <definition> element
var objDesktopModule =
DesktopModuleController.GetDesktopModuleByModuleName(
XmlUtils.GetNodeValue(nodeModule, "definition", ""), Null.NullInteger);
if (objDesktopModule != null)
{
//Get the moduleDefinition from the <moduledefinition> element
var friendlyName = XmlUtils.GetNodeValue(nodeModule, "moduledefinition", "");
if (string.IsNullOrEmpty(friendlyName))
{
//Module is pre 4.3.5 so get the first Module Definition (at least it won't throw an error then)
var moduleDefinitions =
ModuleDefinitionController.GetModuleDefinitionsByDesktopModuleID(
objDesktopModule.DesktopModuleID).Values;
foreach (
var moduleDefinition in
moduleDefinitions)
{
objModuleDefinition = moduleDefinition;
break;
}
}
else
{
//Module is 4.3.5 or later so get the Module Definition by its friendly name
objModuleDefinition = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(friendlyName,
objDesktopModule.
DesktopModuleID);
}
}
return(objModuleDefinition);
}
private ModuleDefinitionInfo ImportManifest()
{
ModuleDefinitionInfo moduleDefinition = null;
try
{
var folder = PathUtils.Instance.RemoveTrailingSlash(GetSourceFolder());
var manifest = Server.MapPath("~/DesktopModules/" + folder + "/" + cboFile.SelectedValue);
var installer = new Installer(manifest, Request.MapPath("."), true);
if (installer.IsValid)
{
installer.InstallerInfo.Log.Logs.Clear();
installer.Install();
if (installer.IsValid)
{
var desktopModule = DesktopModuleController.GetDesktopModuleByPackageID(installer.InstallerInfo.PackageID);
if (desktopModule != null && desktopModule.ModuleDefinitions.Count > 0)
{
foreach (var kvp in desktopModule.ModuleDefinitions)
{
moduleDefinition = kvp.Value;
break; // TODO: might not be correct. Was : Exit For
}
}
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("InstallError.Text", LocalResourceFile), UI.Skins.Controls.ModuleMessage.ModuleMessageType.RedError);
phInstallLogs.Controls.Add(installer.InstallerInfo.Log.GetLogsTable());
}
}
else
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("InstallError.Text", LocalResourceFile), UI.Skins.Controls.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), UI.Skins.Controls.ModuleMessage.ModuleMessageType.RedError);
}
return(moduleDefinition);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Reads a Module Definitions from an XmlReader
/// </summary>
/// <param name="reader">The XmlReader to use</param>
/// <history>
/// [cnurse] 01/17/2008 Created
/// </history>
/// -----------------------------------------------------------------------------
private void ReadModuleDefinitions(XmlReader reader)
{
reader.ReadStartElement("moduleDefinitions");
do
{
reader.ReadStartElement("moduleDefinition");
//Create new ModuleDefinition object
var moduleDefinition = new ModuleDefinitionInfo();
//Load it from the Xml
moduleDefinition.ReadXml(reader);
//Add to the collection
ModuleDefinitions.Add(moduleDefinition.FriendlyName, moduleDefinition);
} while (reader.ReadToNextSibling("moduleDefinition"));
}
private void ProcessModules(XPathNavigator moduleNav, string moduleFolder)
{
ModuleDefinitionInfo definition = new ModuleDefinitionInfo();
definition.FriendlyName = Util.ReadElement(moduleNav, "friendlyname");
string cacheTime = Util.ReadElement(moduleNav, "cachetime");
if (!string.IsNullOrEmpty(cacheTime))
{
definition.DefaultCacheTime = int.Parse(cacheTime);
}
foreach (XPathNavigator controlNav in moduleNav.Select("controls/control"))
{
ProcessControls(controlNav, moduleFolder, definition);
}
DesktopModule.ModuleDefinitions[definition.FriendlyName] = definition;
}
/// <summary>
/// Convert ModuleDefinitionInfo to ModuleDefinition.
/// </summary>
/// <param name="moduleDefinitionInfo">Module definition info</param>
/// <returns>Module definition</returns>
public static ModuleDefinition ToModuleDefinition(this ModuleDefinitionInfo moduleDefinitionInfo)
{
if (moduleDefinitionInfo is null)
{
return(null);
}
return(new ModuleDefinition()
{
ModuleDefId = moduleDefinitionInfo.ModuleDefId,
KeyName = moduleDefinitionInfo.KeyName,
Name = moduleDefinitionInfo.Name,
Path = moduleDefinitionInfo.Path,
Namespace = moduleDefinitionInfo.Namespace,
Version = moduleDefinitionInfo.Version
});
}
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 static void AddUpdateLoginModule(int TabID, int PortalId)
{
try
{
using (VanjaroRepo vrepo = new VanjaroRepo())
{
LoginModule loginModule = null;
ModuleDefinitionInfo moduleDefinitionInfo = ModuleDefinitionController.GetModuleDefinitionByFriendlyName(Components.Constants.AccountLogin);
System.Collections.Generic.List <LoginModule> moduleInfo = vrepo.Fetch <LoginModule>("Select T.PortalID,Tabm.TabID,Tabm.ModuleID,Tabm.PaneName,Tabm.IsDeleted from TabModules Tabm inner join Tabs T On Tabm.TabID = t.TabID Where PortalID=@0 AND ModuleTitle= @1", PortalId, Components.Constants.AccountLogin);
foreach (LoginModule d in moduleInfo)
{
loginModule = d;
}
if (loginModule == null)
{
ModuleInfo module = new ModuleInfo
{
PortalID = PortalId,
TabID = TabID,
ModuleOrder = 1,
ModuleTitle = moduleDefinitionInfo.FriendlyName,
PaneName = "ContentPane",
ModuleDefID = moduleDefinitionInfo.ModuleDefID,
CacheTime = moduleDefinitionInfo.DefaultCacheTime,
InheritViewPermissions = true,
AllTabs = false
};
int ModuleID = ModuleController.Instance.AddModule(module);
ModuleController.Instance.DeleteTabModule(TabID, ModuleID, true);
}
else
{
ModuleController.Instance.MoveModule(loginModule.ModuleID, loginModule.TabID, TabID, loginModule.PaneName);
if (!loginModule.IsDeleted)
{
ModuleController.Instance.DeleteTabModule(TabID, loginModule.ModuleID, true);
}
}
}
}
catch (Exception exc) { Exceptions.LogException(exc); }
}
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);
}
