private Containers.Container LoadContainerFromQueryString(ModuleInfo module, HttpRequest request)
{
Containers.Container container = null;
int previewModuleId = -1;
if (request.QueryString["ModuleId"] != null)
{
Int32.TryParse(request.QueryString["ModuleId"], out previewModuleId);
}
//load user container ( based on cookie )
if ((request.QueryString["ContainerSrc"] != null) && (module.ModuleID == previewModuleId || previewModuleId == -1))
{
string containerSrc = SkinController.FormatSkinSrc(Globals.QueryStringDecode(request.QueryString["ContainerSrc"]) + ".ascx", PortalSettings);
container = LoadContainerByPath(containerSrc);
}
return(container);
}
/// <summary>
/// Prepend ascx control directives to file contents.
/// </summary>
/// <param name="Registrations">ArrayList of registration directives.</param>
/// <remarks>
/// This procedure formats the @Control directive and prepends it and all
/// registration directives to the file contents.
/// </remarks>
public string PrependASCXDirectives(ArrayList Registrations)
{
string Messages = "";
string Prefix = "";
// if the skin source is an HTML document, extract the content within the <body> tags
string strPattern = "<\\s*body[^>]*>(?<skin>.*)<\\s*/\\s*body\\s*>";
Match objMatch = Regex.Match(this.Contents, strPattern, RegexOptions.IgnoreCase | RegexOptions.Singleline);
if (objMatch.Groups[1].Value != "")
{
this.Contents = objMatch.Groups[1].Value;
}
// format and save @Control directive
if (this.SkinRoot == SkinInfo.RootSkin)
{
//Prefix += "<%@ Control language=\"vb\" CodeBehind=\"~/admin/" + SkinRoot + "/skin.vb\" AutoEventWireup=\"false\" Explicit=\"True\" Inherits=\"DotNetNuke.UI.Skins.Skin\" %>" + Environment.NewLine;
Prefix += "<%@ Control language=\"c#\" CodeBehind=\"~/Admin/" + SkinRoot + "/Skin.cs\" AutoEventWireup=\"true\" Inherits=\"DotNetNuke.UI.Skins.Skin\" %>" + Environment.NewLine;
}
else if (this.SkinRoot == SkinInfo.RootContainer)
{
//Prefix += "<%@ Control language=\"vb\" CodeBehind=\"~/admin/" + SkinRoot + "/container.vb\" AutoEventWireup=\"false\" Explicit=\"True\" Inherits=\"DotNetNuke.UI.Containers.Container\" %>" + Environment.NewLine;
Prefix += "<%@ Control language=\"c#\" CodeBehind=\"~/Admin/" + SkinRoot + "/Container.cs\" AutoEventWireup=\"true\" Inherits=\"DotNetNuke.UI.Containers.Container\" %>" + Environment.NewLine;
}
Messages += SkinController.FormatMessage(CONTROL_DIR, HttpUtility.HtmlEncode(Prefix), 2, false);
// add preformatted Control Registrations
foreach (string Item in Registrations)
{
Messages += SkinController.FormatMessage(CONTROL_REG, HttpUtility.HtmlEncode(Item), 2, false);
Prefix += Item;
}
// update file contents to include ascx header information
this.Contents = Prefix + this.Contents;
return(Messages);
}
private bool ProcessSlaveModule()
{
var success = true;
var key = UIUtilities.GetControlKey();
var moduleId = UIUtilities.GetModuleId(key);
var slaveModule = UIUtilities.GetSlaveModule(moduleId, key, PortalSettings.ActiveTab.TabID);
Pane pane;
Panes.TryGetValue(Globals.glbDefaultPane.ToLowerInvariant(), out pane);
slaveModule.PaneName = Globals.glbDefaultPane;
slaveModule.ContainerSrc = PortalSettings.ActiveTab.ContainerSrc;
if (String.IsNullOrEmpty(slaveModule.ContainerSrc))
{
slaveModule.ContainerSrc = PortalSettings.DefaultPortalContainer;
}
slaveModule.ContainerSrc = SkinController.FormatSkinSrc(slaveModule.ContainerSrc, PortalSettings);
slaveModule.ContainerPath = SkinController.FormatSkinPath(slaveModule.ContainerSrc);
var moduleControl = ModuleControlController.GetModuleControlByControlKey(key, slaveModule.ModuleDefID);
if (moduleControl != null)
{
slaveModule.ModuleControlId = moduleControl.ModuleControlID;
slaveModule.IconFile = moduleControl.IconFile;
if (ModulePermissionController.HasModuleAccess(slaveModule.ModuleControl.ControlType, Null.NullString, slaveModule))
{
success = InjectModule(pane, slaveModule);
}
else
{
Response.Redirect(Globals.AccessDeniedURL(Localization.GetString("ModuleAccess.Error")), true);
}
}
return(success);
}
/// <summary>
/// Process regular expression matches.
/// </summary>
/// <param name="m">Regular expression match for path information which requires processing.</param>
/// <returns>Properly formatted path information.</returns>
/// <remarks>
/// The handler is invoked by the Regex.Replace method once for each match that
/// it encounters. The returned value of the handler is substituted for the
/// original match. So the handler properly formats the path information and
/// returns it in favor of the improperly formatted match.
/// </remarks>
private string MatchHandler(Match m)
{
string strOldTag = m.Groups["tag"].Value + m.Groups["content"].Value + m.Groups["endtag"].Value;
string strNewTag = strOldTag;
switch (this.ParseOption)
{
case SkinParser.Localized:
// if the tag does not contain the localized path
if (strNewTag.IndexOf(this.SkinPath) == -1)
{
// insert the localized path
strNewTag = m.Groups["tag"].Value + this.SkinPath + m.Groups["content"].Value + m.Groups["endtag"].Value;
}
break;
case SkinParser.Portable:
// if the tag does not contain a reference to the skinpath
if (strNewTag.ToLower().IndexOf("<%= skinpath %>") == -1)
{
// insert the skinpath
strNewTag = m.Groups["tag"].Value + "<%= SkinPath %>" + m.Groups["content"].Value + m.Groups["endtag"].Value;
}
// if the tag contains the localized path
if (strNewTag.IndexOf(this.SkinPath) != -1)
{
// remove the localized path
strNewTag = strNewTag.Replace(this.SkinPath, "");
}
break;
}
m_Messages += SkinController.FormatMessage(SUBST, string.Format(SUBST_DETAIL, HttpUtility.HtmlEncode(strOldTag), HttpUtility.HtmlEncode(strNewTag)), 2, false);
return(strNewTag);
}
private Containers.Container LoadNoContainer(ModuleInfo module)
{
string noContainerSrc = "[G]" + SkinController.RootContainer + "/_default/No Container.ascx";
Containers.Container container = null;
//if the module specifies that no container should be used
if (module.DisplayTitle == false)
{
//always display container if the current user is the administrator or the module is being used in an admin case
bool displayTitle = ModulePermissionController.CanEditModuleContent(module) || Globals.IsAdminSkin();
//unless the administrator is in view mode
if (displayTitle)
{
displayTitle = (PortalSettings.UserMode != PortalSettings.Mode.View);
}
if (displayTitle == false)
{
container = LoadContainerByPath(SkinController.FormatSkinSrc(noContainerSrc, PortalSettings));
}
}
return(container);
}
private Containers.Container LoadModuleContainer(ModuleInfo module)
{
var containerSrc = Null.NullString;
var request = PaneControl.Page.Request;
Containers.Container container = null;
if (PortalSettings.EnablePopUps && UrlUtils.InPopUp())
{
containerSrc = module.ContainerPath + "popUpContainer.ascx";
//Check Skin for a popup Container
if (module.ContainerSrc == PortalSettings.ActiveTab.ContainerSrc)
{
if (File.Exists(HttpContext.Current.Server.MapPath(containerSrc)))
{
container = LoadContainerByPath(containerSrc);
}
}
//error loading container - load default popup container
if (container == null)
{
containerSrc = Globals.HostPath + "Containers/_default/popUpContainer.ascx";
container = LoadContainerByPath(containerSrc);
}
}
else
{
container = (LoadContainerFromQueryString(module, request) ?? LoadContainerFromCookie(request)) ?? LoadNoContainer(module);
if (container == null)
{
//Check Skin for Container
var masterModules = PortalSettings.ActiveTab.ChildModules;
if (masterModules.ContainsKey(module.ModuleID) && string.IsNullOrEmpty(masterModules[module.ModuleID].ContainerSrc))
{
//look for a container specification in the skin pane
if (PaneControl != null)
{
if ((PaneControl.Attributes["ContainerSrc"] != null))
{
container = LoadContainerFromPane();
}
}
}
}
//else load assigned container
if (container == null)
{
containerSrc = module.ContainerSrc;
if (!String.IsNullOrEmpty(containerSrc))
{
containerSrc = SkinController.FormatSkinSrc(containerSrc, PortalSettings);
container = LoadContainerByPath(containerSrc);
}
}
//error loading container - load from tab
if (container == null)
{
containerSrc = PortalSettings.ActiveTab.ContainerSrc;
if (!String.IsNullOrEmpty(containerSrc))
{
containerSrc = SkinController.FormatSkinSrc(containerSrc, PortalSettings);
container = LoadContainerByPath(containerSrc);
}
}
//error loading container - load default
if (container == null)
{
containerSrc = SkinController.FormatSkinSrc(SkinController.GetDefaultPortalContainer(), PortalSettings);
container = LoadContainerByPath(containerSrc);
}
}
//Set container path
module.ContainerPath = SkinController.FormatSkinPath(containerSrc);
//set container id to an explicit short name to reduce page payload
container.ID = "ctr";
//make the container id unique for the page
if (module.ModuleID > -1)
{
container.ID += module.ModuleID.ToString();
}
return(container);
}
/// <summary>
/// SkinFileProcessor class constructor.
/// </summary>
/// <param name="SkinPath">File path to the portals upload directory.</param>
/// <param name="SkinRoot">Specifies type of skin (Skins or Containers)</param>
/// <param name="SkinName">Name of folder in which skin will reside (Zip file name)</param>
/// <remarks>
/// The constructor primes the file processor with path information and
/// control data that should only be retrieved once. It checks for the
/// existentce of a skin level attribute file and read it in, if found.
/// It also sorts through the complete list of controls and creates
/// a hashtable which contains only the skin objects and their source paths.
/// These are recognized by their ControlKey's which are formatted like
/// tokens ("[TOKEN]"). The hashtable is required for speed as it will be
/// processed for each token found in the source file by the Control Parser.
/// </remarks>
public SkinFileProcessor(string SkinPath, string SkinRoot, string SkinName)
{
this.Message += SkinController.FormatMessage(INITIALIZE_PROCESSOR, SkinRoot + " :: " + SkinName, 0, false);
// Save path information for future use
m_SkinRoot = SkinRoot;
m_SkinPath = SkinPath;
m_SkinName = SkinName;
// Check for and read skin package level attribute information file
string FileName = this.SkinPath + this.SkinRoot + "\\" + this.SkinName + "\\" + SkinRoot.Substring(0, SkinRoot.Length - 1) + ".xml";
if (File.Exists(FileName))
{
try
{
this.SkinAttributes.Load(FileName);
this.Message += SkinController.FormatMessage(PACKAGE_LOAD, Path.GetFileName(FileName), 2, false);
}
catch (Exception ex)
{
// could not load XML file
this.Message += SkinController.FormatMessage(string.Format(PACKAGE_LOAD_ERROR, ex.Message), Path.GetFileName(FileName), 2, true);
}
}
// Retrieve a list of available controls
ModuleControlController objModuleControls = new ModuleControlController();
ArrayList arrModuleControls = objModuleControls.GetModuleControls(Null.NullInteger);
// Look at every control
string Token;
int i;
ModuleControlInfo objModuleControl;
for (i = 0; i <= arrModuleControls.Count - 1; i++)
{
objModuleControl = (ModuleControlInfo)arrModuleControls[i];
// If the control is a skin object, save the key and source in the hash table
if (objModuleControl.ControlType == SecurityAccessLevel.SkinObject)
{
Token = objModuleControl.ControlKey.ToUpper();
// If the control is already in the hash table
if (m_ControlList.ContainsKey(Token))
{
// Record an error message and skip it
this.Message += SkinController.FormatMessage(string.Format(DUPLICATE_ERROR, objModuleControl.ControlKey.ToString().ToUpper()), string.Format(DUPLICATE_DETAIL, ((string)m_ControlList[Token]), objModuleControl.ControlSrc.ToString()), 2, true);
}
else
{
// Add it
this.Message += SkinController.FormatMessage(string.Format(LOAD_SKIN_TOKEN, objModuleControl.ControlKey.ToString().ToUpper()), objModuleControl.ControlSrc.ToString(), 2, false);
m_ControlList.Add(Token, objModuleControl.ControlSrc);
}
}
}
// Instantiate the control parser with the list of skin objects
m_ControlFactory = new ControlParser(m_ControlList);
}
/// <summary>
/// SkinFile class constructor.
/// </summary>
/// <param name="SkinRoot"></param>
/// <param name="FileName"></param>
/// <param name="SkinAttributes"></param>
/// <remarks>
/// The constructor primes the utility class with basic file information.
/// It also checks for the existentce of a skinfile level attribute file
/// and read it in, if found.
/// </remarks>
public SkinFile(string SkinRoot, string FileName, XmlDocument SkinAttributes)
{
// capture file information
m_FileName = FileName;
m_FileExtension = Path.GetExtension(FileName);
m_SkinRoot = SkinRoot;
m_FileAttributes = SkinAttributes;
// determine and store path to portals skin root folder
string strTemp = FileName.Replace(Path.GetFileName(FileName), "");
strTemp = strTemp.Replace("\\", "/");
m_SkinRootPath = Globals.ApplicationPath + strTemp.Substring(Strings.InStr(1, strTemp.ToUpper(), "/PORTALS", 0) - 1);
// read file contents
this.Contents = Read(FileName);
// setup some attributes based on file extension
switch (this.FileExtension)
{
case ".htm":
// set output file name to <filename>.ASCX
m_WriteFileName = FileName.Replace(Path.GetExtension(FileName), ".ascx");
// capture warning if file does not contain a id="ContentPane" or [CONTENTPANE]
Regex PaneCheck1 = new Regex("\\s*id\\s*=\\s*\"" + Globals.glbDefaultPane + "\"", RegexOptions.IgnoreCase);
Regex PaneCheck2 = new Regex("\\s*[" + Globals.glbDefaultPane + "]", RegexOptions.IgnoreCase);
if (PaneCheck1.IsMatch(this.Contents) == false && PaneCheck2.IsMatch(this.Contents) == false)
{
m_Messages += SkinController.FormatMessage(FILE_FORMAT_ERROR, string.Format(FILE_FORMAT_ERROR, FileName), 2, true);
}
// Check for existence of and load skin file level attribute information
if (File.Exists(FileName.Replace(this.FileExtension, ".xml")))
{
try
{
m_FileAttributes.Load(FileName.Replace(this.FileExtension, ".xml"));
m_Messages += SkinController.FormatMessage(FILE_LOAD, FileName, 2, false);
}
catch (Exception) // could not load XML file
{
m_FileAttributes = SkinAttributes;
m_Messages += SkinController.FormatMessage(FILE_LOAD_ERROR, FileName, 2, true);
}
}
break;
case ".html":
// set output file name to <filename>.ASCX
m_WriteFileName = FileName.Replace(Path.GetExtension(FileName), ".ascx");
// capture warning if file does not contain a id="ContentPane" or [CONTENTPANE]
PaneCheck1 = new Regex("\\s*id\\s*=\\s*\"" + Globals.glbDefaultPane + "\"", RegexOptions.IgnoreCase);
PaneCheck2 = new Regex("\\s*[" + Globals.glbDefaultPane + "]", RegexOptions.IgnoreCase);
if (PaneCheck1.IsMatch(this.Contents) == false && PaneCheck2.IsMatch(this.Contents) == false)
{
m_Messages += SkinController.FormatMessage(FILE_FORMAT_ERROR, string.Format(FILE_FORMAT_ERROR, FileName), 2, true);
}
// Check for existence of and load skin file level attribute information
if (File.Exists(FileName.Replace(this.FileExtension, ".xml")))
{
try
{
m_FileAttributes.Load(FileName.Replace(this.FileExtension, ".xml"));
m_Messages += SkinController.FormatMessage(FILE_LOAD, FileName, 2, false);
}
catch (Exception) // could not load XML file
{
m_FileAttributes = SkinAttributes;
m_Messages += SkinController.FormatMessage(FILE_LOAD_ERROR, FileName, 2, true);
}
}
break;
default:
// output file name is same as input file name
m_WriteFileName = FileName;
break;
}
}
/// <summary>
/// Process regular expression matches.
/// </summary>
/// <param name="m">Regular expression match for token which requires processing.</param>
/// <returns>Properly formatted token.</returns>
/// <remarks>
/// The handler is invoked by the Regex.Replace method once for each match that
/// it encounters. The returned value of the handler is substituted for the
/// original match. So the handler properly formats the replacement for the
/// token and returns it instead. If an unknown token is encountered, the token
/// is unmodified. This can happen if a token is used for a skin object which
/// has not yet been installed.
/// </remarks>
private string TokenMatchHandler(Match m)
{
string TOKEN_PROC = Localization.GetString("ProcessToken", Globals.GetPortalSettings());
string TOKEN_SKIN = Localization.GetString("SkinToken", Globals.GetPortalSettings());
string TOKEN_PANE = Localization.GetString("PaneToken", Globals.GetPortalSettings());
string TOKEN_FOUND = Localization.GetString("TokenFound", Globals.GetPortalSettings());
string TOKEN_FORMAT = Localization.GetString("TokenFormat", Globals.GetPortalSettings());
string TOKEN_NOTFOUND_INFILE = Localization.GetString("TokenNotFoundInFile", Globals.GetPortalSettings());
string CONTROL_FORMAT = Localization.GetString("ControlFormat", Globals.GetPortalSettings());
string TOKEN_NOTFOUND = Localization.GetString("TokenNotFound", Globals.GetPortalSettings());
string Token = m.Groups["token"].Value.ToUpper();
string ControlName = Token + m.Groups["instance"].Value;
// if the token has an instance name, use it to look for the corresponding attributes
string AttributeNode = Token + Convert.ToString((m.Groups["instance"].Value == "") ? "" : (":" + m.Groups["instance"].Value));
this.Messages += SkinController.FormatMessage(TOKEN_PROC, "[" + AttributeNode + "]", 2, false);
// if the token is a recognized skin control
if (this.ControlList.ContainsKey(Token) == true || Token.IndexOf("CONTENTPANE") != -1)
{
string SkinControl = "";
if (this.ControlList.ContainsKey(Token))
{
this.Messages += SkinController.FormatMessage(TOKEN_SKIN, ((string)this.ControlList[Token]), 2, false);
}
else
{
this.Messages += SkinController.FormatMessage(TOKEN_PANE, Token, 2, false);
}
// if there is an attribute file
if (this.Attributes.DocumentElement != null)
{
// look for the the node of this instance of the token
XmlNode xmlSkinAttributeRoot = this.Attributes.DocumentElement.SelectSingleNode("descendant::Object[Token='[" + AttributeNode + "]']");
// if the token is found
if (xmlSkinAttributeRoot != null)
{
this.Messages += SkinController.FormatMessage(TOKEN_FOUND, "[" + AttributeNode + "]", 2, false);
// process each token attribute
XmlNode xmlSkinAttribute;
foreach (XmlNode tempLoopVar_xmlSkinAttribute in xmlSkinAttributeRoot.SelectNodes(".//Settings/Setting"))
{
xmlSkinAttribute = tempLoopVar_xmlSkinAttribute;
if (xmlSkinAttribute.SelectSingleNode("Value").InnerText != "")
{
// append the formatted attribute to the inner contents of the control statement
this.Messages += SkinController.FormatMessage(TOKEN_FORMAT, xmlSkinAttribute.SelectSingleNode("Name").InnerText + "=\"" + xmlSkinAttribute.SelectSingleNode("Value").InnerText + "\"", 2, false);
SkinControl += " " + xmlSkinAttribute.SelectSingleNode("Name").InnerText + "=\"" + xmlSkinAttribute.SelectSingleNode("Value").InnerText.Replace("\"", """) + "\"";
}
}
}
else
{
this.Messages += SkinController.FormatMessage(TOKEN_NOTFOUND_INFILE, "[" + AttributeNode + "]", 2, false);
}
}
if (this.ControlList.ContainsKey(Token))
{
// create the skin object user control tag
SkinControl = "dnn:" + ControlName + " runat=\"server\" id=\"dnn" + ControlName + "\"" + SkinControl;
// Save control registration statement
RegisterList.Add("<%@ Register TagPrefix=\"dnn\" TagName=\"" + ControlName + "\" Src=\"~/" + ((string)this.ControlList[Token]) + "\" %>" + "\r\n");
// return the control statement
this.Messages += SkinController.FormatMessage(CONTROL_FORMAT, "<" + SkinControl + " />", 2, false);
SkinControl = "<" + SkinControl + " />";
}
else // CONTENTPANE
{
if (SkinControl.ToLower().IndexOf("id=") == -1)
{
SkinControl = " id=\"ContentPane\"";
}
SkinControl = "div runat=\"server\"" + SkinControl + "></div";
// return the control statement
this.Messages += SkinController.FormatMessage(CONTROL_FORMAT, "<" + SkinControl + ">", 2, false);
SkinControl = "<" + SkinControl + ">";
}
return(SkinControl);
}
else
{
// return the unmodified token
// note that this is currently protecting array syntax in embedded javascript
// should be fixed in the regular expressions but is not, currently.
this.Messages += SkinController.FormatMessage(TOKEN_NOTFOUND, "[" + m.Groups["token"].Value + "]", 2, false);
return("[" + m.Groups["token"].Value + "]");
}
}
