/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
protected IFileContainer GetFileContainer(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
string currentWorkingDirectory = templateParsingState.GetCWD(me);
XmlAttribute filenameAttribute = me.Attributes["filename"];
if (null == filenameAttribute)
{
me.ParentNode.ParentNode.InsertBefore(
templateParsingState.GenerateWarningNode("filename not specified: " + me.OuterXml),
me.ParentNode);
return null;
}
string filename = templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath(
currentWorkingDirectory,
filenameAttribute.Value);
try
{
return templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.FileSystemResolver.ResolveFile(filename);
}
catch (FileNotFoundException fnfe)
{
log.Warn("Attempted to get permission for a non-existant file: " + filenameAttribute.Value, fnfe);
me.ParentNode.ParentNode.InsertBefore(
templateParsingState.GenerateWarningNode("File doesn't exist: " + me.OuterXml),
me.ParentNode);
return null;
}
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
if (templateParsingState.WebConnection.Session.User.Id == templateParsingState.FileHandlerFactoryLocator.UserFactory.AnonymousUser.Id)
return false;
return templateParsingState.WebConnection.Session.User.Local;
}
/// <summary>
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, XmlNode me)
{
IFileContainer fileContainer = GetFileContainer(templateParsingState, me);
string action = me.Attributes["action"].Value;
return fileContainer.FileConfigurationManager.Actions.ContainsKey(action);
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="fileContainer"></param>
/// <param name="namedPermission"></param>
/// <returns></returns>
protected override bool DetermineCondition(ITemplateParsingState templateParsingState, IFileContainer fileContainer, string namedPermission)
{
foreach (Dictionary<string, object> supportedNamedPermission in fileContainer.FileConfigurationManager.ViewComponents)
if (supportedNamedPermission["NamedPermission"].ToString() == namedPermission)
return true;
return false;
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
IFileContainer fileContainer = GetFileContainer(templateParsingState, me);
if (null == fileContainer)
return false;
return MinimumPermission <= fileContainer.LoadPermission(templateParsingState.WebConnection.Session.User.Id);
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="fileContainer"></param>
/// <param name="namedPermission"></param>
/// <returns></returns>
protected override bool DetermineCondition(ITemplateParsingState templateParsingState, IFileContainer fileContainer, string namedPermission)
{
// Always return true for administrators
if (templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.UserManagerHandler.IsUserInGroup(
templateParsingState.WebConnection.Session.User.Id,
templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.UserFactory.Administrators.Id))
return true;
return fileContainer.HasNamedPermissions(templateParsingState.WebConnection.Session.User.Id, namedPermission);
}
/// <summary>
///
/// </summary>
/// <param name="TemplateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState TemplateParsingState, System.Xml.XmlNode me)
{
XmlAttribute valueAttribute = me.Attributes["value"];
if (null != valueAttribute)
if (null != valueAttribute.Value)
if (valueAttribute.Value.Length > 0)
return true;
return false;
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, XmlNode me)
{
XmlAttribute l = me.Attributes["l"];
XmlAttribute r = me.Attributes["r"];
if ((null == l) || (null == r))
return false;
return l.Value.Equals(r.Value);
}
private void HandleConditional(
ITemplateParsingState templateParsingState,
IDictionary<string, object> getParameters,
XmlNode conditionalNode)
{
Dictionary<string, ITemplateConditionHandler> templateConditionHandlers = templateParsingState.TemplateHandlerLocator.TemplateConditionHandlers;
XmlNode current = conditionalNode.FirstChild;
bool conditionMet = false;
// Note: Looping continues after the condition is met to ensure that all nodes are in the correct namespace
while (null != current)
{
// Make sure the namespace is proper
if (current.NamespaceURI != templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)
conditionalNode.ParentNode.InsertBefore(
templateParsingState.GenerateWarningNode("All nodes within an <if> must be of " + templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace + " namespace: " + current.OuterXml),
conditionalNode);
else
{
// Make sure the node is supported
ITemplateConditionHandler templateConditionHandler;
if (!templateConditionHandlers.TryGetValue(current.LocalName, out templateConditionHandler))
conditionalNode.ParentNode.InsertBefore(
templateParsingState.GenerateWarningNode("There is no condition handler for " + current.LocalName + ": " + current.OuterXml),
conditionalNode);
if (!conditionMet)
try
{
if (templateConditionHandler.IsConditionMet(templateParsingState, current))
{
conditionMet = true;
foreach (XmlNode xmlNode in Enumerable<XmlNode>.FastCopy(Enumerable<XmlNode>.Filter(current.ChildNodes)))
conditionalNode.ParentNode.InsertBefore(xmlNode, conditionalNode);
}
}
catch (Exception e)
{
log.Error("Unhandled error for condition tag " + current.LocalName + ": " + current.OuterXml, e);
conditionalNode.ParentNode.InsertBefore(
templateParsingState.GenerateWarningNode("An unhandled error occured processing: " + current.OuterXml),
conditionalNode);
}
}
current = current.NextSibling;
}
conditionalNode.ParentNode.RemoveChild(conditionalNode);
}
void PostProcessElement(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
if (element.LocalName == "trim" && element.NamespaceURI == templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)
{
XmlAttribute maxtagsAttribute = element.Attributes["maxtags"];
XmlAttribute maxlengthAttribute = element.Attributes["maxlength"];
ulong maxtags = ulong.MaxValue;
if (null != maxtagsAttribute)
ulong.TryParse(maxtagsAttribute.Value, out maxtags);
ulong maxlength = ulong.MaxValue;
if (null != maxlengthAttribute)
ulong.TryParse(maxlengthAttribute.Value, out maxlength);
ulong numTags = 0;
ulong length = 0;
bool trimming = false;
foreach (XmlNode xmlNode in Enumerable<XmlNode>.FastCopy(XmlHelper.IterateAll<XmlNode>(element)))
{
if (trimming)
xmlNode.ParentNode.RemoveChild(xmlNode);
else if (!(xmlNode is XmlComment))
{
numTags++;
if (numTags > maxtags)
{
xmlNode.ParentNode.RemoveChild(xmlNode);
trimming = true;
}
else if (xmlNode is XmlText)
{
XmlText xmlText = (XmlText)xmlNode;
ulong textLength = Convert.ToUInt64(xmlText.InnerText.Length);
if (length + textLength > maxlength)
{
xmlText.InnerText = xmlText.InnerText.Substring(0, Convert.ToInt32(maxlength - length));
trimming = true;
}
else
length += textLength;
}
}
}
templateParsingState.ReplaceNodes(element, element.ChildNodes);
}
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, XmlNode me)
{
IFileContainer fileContainer = GetFileContainer(templateParsingState, me);
if (null == fileContainer)
return false;
XmlAttribute namedPermissionAttribute = me.Attributes["namedpermission"];
if (null == namedPermissionAttribute)
{
me.ParentNode.ParentNode.InsertBefore(
templateParsingState.GenerateWarningNode("namedpermission not specified: " + me.OuterXml),
me.ParentNode);
return false;
}
return DetermineCondition(templateParsingState, fileContainer, namedPermissionAttribute.Value);
}
IEnumerable<XmlNode> DoParseTag(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
// Generate the xml
StringBuilder xml = new StringBuilder(
string.Format("<html xmlns=\"{0}\"><head></head><body>", templateParsingState.TemplateDocument.FirstChild.NamespaceURI),
element.OuterXml.Length);
foreach (XmlNode xmlNode in element.ChildNodes)
if (xmlNode is XmlText)
xml.Append(((XmlText)xmlNode).InnerText);
else
xml.Append(xmlNode.OuterXml);
xml.Append("</body></html>");
XmlDocument xmlDocument;
try
{
xmlDocument = templateParsingState.LoadXmlDocument(
xml.ToString(),
templateParsingState.GetXmlParseMode(element),
element.OuterXml);
}
catch (WebResultsOverrideException wroe)
{
templateParsingState.ReplaceNodes(
element,
templateParsingState.GenerateWarningNode(wroe.WebResults.ResultsAsString));
return new XmlNode[0];
}
// import the new tags
IEnumerable<XmlNode> importedNodes = Enumerable<XmlNode>.FastCopy(Enumerable<XmlNode>.Cast(
xmlDocument.FirstChild.ChildNodes[1].ChildNodes));
templateParsingState.ReplaceNodes(element, importedNodes);
return importedNodes;
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
return templateParsingState.WebConnection.Session.User.Id != templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.UserFactory.AnonymousUser.Id;
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
return !templateParsingState.WebConnection.Session.User.Local;
}
void ITemplateProcessor.Register(ITemplateParsingState templateParsingState)
{
templateParsingState.ProcessElementForConditionalsAndComponents += ProcessElementForConditionalsAndComponents;
}
void DoSafeParseTag(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
MakeSafe(DoParseTag(templateParsingState, getParameters, element));
}
void DoSafeTag(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
IEnumerable<XmlNode> childNodes = Enumerable<XmlNode>.FastCopy(Enumerable<XmlNode>.Cast(element.ChildNodes));
templateParsingState.ReplaceNodes(element, childNodes);
MakeSafe(childNodes);
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, XmlNode me)
{
return templateParsingState.WebConnection.UserAgent is IMobile;
}
void ProcessElementForDependanciesAndTemplates(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
if (templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace == element.NamespaceURI)
if ("safeparse" == element.LocalName)
DoSafeParseTag(templateParsingState, getParameters, element);
else if ("safe" == element.LocalName)
DoSafeTag(templateParsingState, getParameters, element);
else if ("parse" == element.LocalName)
DoParseTag(templateParsingState, getParameters, element);
}
void ProcessElementForDependanciesAndTemplates(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
if (element.NamespaceURI == templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)
if (element.LocalName == "script")
{
XmlAttribute srcAttribute = element.Attributes["src"];
if (null != srcAttribute)
templateParsingState.AddScript(templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath(
templateParsingState.GetCWD(element),
srcAttribute.Value));
XmlHelper.RemoveFromParent(element);
}
else if (element.LocalName == "open")
{
XmlAttribute filenameAttribute = element.Attributes["filename"];
XmlAttribute varnameAttribute = element.Attributes["varname"];
if ((null != filenameAttribute) && (null != varnameAttribute))
{
templateParsingState.AddScript(string.Format(
"{0}?Method=GetJSW&assignToVariable={1}",
templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath(templateParsingState.GetCWD(element), filenameAttribute.Value),
varnameAttribute.Value));
XmlHelper.RemoveFromParent(element);
}
else if (templateParsingState.WebConnection.CookiesFromBrowser.ContainsKey(templateParsingState.TemplateHandlerLocator.TemplatingConstants.JavascriptDebugModeCookie))
{
XmlElement replacementScript = templateParsingState.TemplateDocument.CreateElement("", "script", templateParsingState.TemplateHandlerLocator.TemplatingConstants.HtmlNamespace);
XmlText alertText = templateParsingState.TemplateDocument.CreateTextNode("alert('Invalid open: " + element.OuterXml + "');");
replacementScript.AppendChild(alertText);
templateParsingState.ReplaceNodes(element, replacementScript);
}
}
else if (element.LocalName == "css")
{
XmlAttribute srcAttribute = element.Attributes["src"];
if (null != srcAttribute)
templateParsingState.CssFiles.AddLast(templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath(
templateParsingState.GetCWD(element),
srcAttribute.Value));
XmlHelper.RemoveFromParent(element);
}
else if (element.LocalName == "inserthead")
{
// Try reading loc, default to 0
XmlAttribute locAttribute = element.Attributes["loc"];
double loc;
if (null != locAttribute)
{
if (!double.TryParse(locAttribute.Value, out loc))
loc = 0;
}
else
loc = 0;
LinkedList<XmlNode> insertNodes;
if (!templateParsingState.HeaderNodes.TryGetValue(loc, out insertNodes))
{
insertNodes = new LinkedList<XmlNode>();
templateParsingState.HeaderNodes[loc] = insertNodes;
}
foreach (XmlNode headNode in element.ChildNodes)
if (loc < 0)
insertNodes.AddFirst(headNode);
else
insertNodes.AddLast(headNode);
XmlHelper.RemoveFromParent(element);
}
}
void ProcessElementForConditionalsAndComponents(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
if (element.NamespaceURI == templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)
if (element.LocalName == "if")
HandleConditional(templateParsingState, getParameters, element);
else if (element.LocalName == "component")
LoadComponent(templateParsingState, getParameters, element);
else if (element.LocalName == "snipit")
LoadSnipit(templateParsingState, getParameters, element);
}
private void GenerateScriptAndCssTags(ITemplateParsingState templateParsingState, XmlNode headNode)
{
XmlDocument templateDocument = templateParsingState.TemplateDocument;
LinkedList<string> cssFiles = templateParsingState.CssFiles;
foreach (string script in templateParsingState.Scripts)
{
XmlNode scriptNode = templateDocument.CreateElement("script", headNode.NamespaceURI);
XmlAttribute srcAttribute = templateDocument.CreateAttribute("src");
srcAttribute.Value = script;
// type="text/javascript"
XmlAttribute typeAttribute = templateDocument.CreateAttribute("type");
typeAttribute.Value = "text/javascript";
scriptNode.Attributes.Append(srcAttribute);
scriptNode.Attributes.Append(typeAttribute);
scriptNode.InnerText = "";
headNode.AppendChild(scriptNode);
}
HashSet<string> addedCssFiles = new HashSet<string>();
foreach (string cssFile in cssFiles)
if (!addedCssFiles.Contains(cssFile))
{
XmlNode cssNode = templateDocument.CreateElement("link", headNode.NamespaceURI);
// <link rel="stylesheet" type="text/css" media="screen, projection" href="//a.fsdn.com/sd/core-tidied.css?T_2_5_0_299" >
XmlAttribute srcAttribute = templateDocument.CreateAttribute("href");
srcAttribute.Value = cssFile;
XmlAttribute typeAttribute = templateDocument.CreateAttribute("type");
typeAttribute.Value = "text/css";
XmlAttribute relAttribute = templateDocument.CreateAttribute("rel");
relAttribute.Value = "stylesheet";
cssNode.Attributes.Append(srcAttribute);
cssNode.Attributes.Append(typeAttribute);
cssNode.Attributes.Append(relAttribute);
headNode.AppendChild(cssNode);
addedCssFiles.Add(cssFile);
}
// If javascript debug mode is off, combile all of the scripts into one that loads all at once
if (!(templateParsingState.WebConnection.CookiesFromBrowser.ContainsKey(
templateParsingState.FileHandlerFactoryLocator.TemplateHandlerLocator.TemplatingConstants.JavascriptDebugModeCookie)))
{
// Generate composite script tag
XmlElement lastLocalScriptTag = null;
LinkedList<string> scriptUrls = new LinkedList<string>();
LinkedList<XmlElement> scriptElements = new LinkedList<XmlElement>();
foreach (XmlElement node in XmlHelper.IterateAllElements(headNode))
if (node.LocalName == "script")
if (templateParsingState.FileHandlerFactoryLocator.TemplateHandlerLocator.TemplatingConstants.HtmlNamespaces.Contains(node.NamespaceURI))
{
// This is a script node
// get the script that's being loaded
string src = node.GetAttribute("src");
if (null != src)
if (src.Length > 0)
if (src.StartsWith("/"))
// Hueristic: All scripts without a ? are merged into one
// If a script has a ?, but it's for a system file or the user database, it can also be merged
if ((!(src.Contains("?"))) || (src.StartsWith("/System/")) || (src.StartsWith("/Users/UserDB?")))
{
lastLocalScriptTag = node;
scriptElements.AddLast(node);
scriptUrls.AddLast(src);
}
else
{
// If the script cannot be merged, then add the BrowserCache GET argument so that the browser can cache it
IWebResults scriptResults = templateParsingState.WebConnection.ShellTo(src);
src = HTTPStringFunctions.AppendGetParameter(
src,
"BrowserCache",
StringGenerator.GenerateHash(scriptResults.ResultsAsString));
node.SetAttribute("src", src);
}
}
// Remove dead script tags and update the last one to load a composite script
if (null != lastLocalScriptTag)
{
foreach (XmlElement node in scriptElements)
if (node != lastLocalScriptTag)
node.ParentNode.RemoveChild(node);
string serializedScriptList = JsonWriter.Serialize(scriptUrls);
string compositeScript = GenerateCompositeJavascript(templateParsingState.WebConnection, scriptUrls);
string hash = StringGenerator.GenerateHash(compositeScript);
string url = FileContainer.FullPath + "?Method=GetCompositeScript";
url = HTTPStringFunctions.AppendGetParameter(url, "scriptUrls", serializedScriptList);
url = HTTPStringFunctions.AppendGetParameter(url, "BrowserCache", hash);
lastLocalScriptTag.SetAttribute("src", url);
}
}
else
{
// Warn when including a missing script
foreach (XmlElement node in XmlHelper.IterateAllElements(headNode))
if (node.LocalName == "script")
{
string src = node.GetAttribute("src");
if (null != src)
if (src.Length > 0)
if (src.StartsWith("/"))
{
src = src.Split('?')[0];
if (!src.Contains("[")) // quick hack so scripts can contain [user]
if (!templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.IsFilePresent(src))
{
node.InnerText = "alert('" + (src + " doesn't exist: " + node.OuterXml).Replace("'", "\\'") + "');";
node.RemoveAttribute("src");
}
}
}
}
}
private static void GenerateHeadTags(ITemplateParsingState templateParsingState, XmlNode headNode)
{
SortedDictionary<double, LinkedList<XmlNode>> headerNodes = templateParsingState.HeaderNodes;
foreach (double loc in headerNodes.Keys)
if (loc < 0)
foreach (XmlNode xmlNode in headerNodes[loc])
headNode.PrependChild(xmlNode);
else
foreach (XmlNode xmlNode in headerNodes[loc])
headNode.InsertAfter(xmlNode, headNode.LastChild);
// handle oc:title, if present
// TODO: Use XPATH
XmlNodeList ocTitleNodes = headNode.OwnerDocument.GetElementsByTagName("title", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace);
if (ocTitleNodes.Count > 1)
for (int ctr = 1; ctr < ocTitleNodes.Count; ctr++)
{
XmlNode ocTitleNode = ocTitleNodes[ctr];
ocTitleNode.ParentNode.RemoveChild(ocTitleNode);
}
if (ocTitleNodes.Count > 0)
{
XmlNode ocTitleNode = ocTitleNodes[0];
bool titleNodePresent = false;
foreach (XmlNode titleNode in headNode.OwnerDocument.GetElementsByTagName("title", headNode.NamespaceURI))
if (titleNode.ParentNode == ocTitleNode.ParentNode)
titleNodePresent = true;
if (!titleNodePresent)
{
XmlNode titleNode = headNode.OwnerDocument.CreateElement("title", headNode.NamespaceURI);
foreach (XmlNode subNode in ocTitleNode.ChildNodes)
titleNode.AppendChild(subNode);
foreach (XmlAttribute attribute in ocTitleNode.Attributes)
titleNode.Attributes.Append(attribute);
ocTitleNode.ParentNode.InsertAfter(titleNode, ocTitleNode);
}
ocTitleNode.ParentNode.RemoveChild(ocTitleNode);
}
}
/// <summary>
/// Always returns true
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
return true;
}
/// <summary>
/// This is to work around a Mozilla quirk where it can't handle empty text areas
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="getParameters"></param>
/// <param name="element"></param>
void EnsureNoEmptyTextareas(ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element)
{
if (element.LocalName == "textarea" && templateParsingState.TemplateHandlerLocator.TemplatingConstants.HtmlNamespaces.Contains(element.NamespaceURI))
if (element.IsEmpty)
element.IsEmpty = false;
}
/// <summary> /// /// </summary> /// <param name="templateParsingState"></param> /// <param name="fileContainer"></param> /// <param name="namedPermission"></param> /// <returns></returns> protected abstract bool DetermineCondition(ITemplateParsingState templateParsingState, IFileContainer fileContainer, string namedPermission);
void ITemplateProcessor.Register(ITemplateParsingState templateParsingState)
{
templateParsingState.PostProcessElement += PostProcessElement;
}
//static ILog log = LogManager.GetLogger<ComponentAndConditionalsResolver>();
void ITemplateProcessor.Register(ITemplateParsingState templateParsingState)
{
templateParsingState.ProcessElementForDependanciesAndTemplates += ProcessElementForDependanciesAndTemplates;
}
/// <summary>
///
/// </summary>
/// <param name="templateParsingState"></param>
/// <param name="me"></param>
/// <returns></returns>
public bool IsConditionMet(ITemplateParsingState templateParsingState, System.Xml.XmlNode me)
{
return templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.UserManagerHandler.IsUserInGroup(
templateParsingState.WebConnection.Session.User.Id,
templateParsingState.WebConnection.WebServer.FileHandlerFactoryLocator.UserFactory.Administrators.Id);
}
private void LoadSnipit(
ITemplateParsingState templateParsingState,
IDictionary<string, object> getParameters,
XmlElement element)
{
XmlAttribute srcAttribute = (XmlAttribute)element.Attributes.GetNamedItem("src", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace);
if (null == srcAttribute)
templateParsingState.ReplaceNodes(
element,
templateParsingState.GenerateWarningNode("oc:src must be specified: " + element.OuterXml));
else
{
string fileName = templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath(
templateParsingState.GetCWD(element),
srcAttribute.Value);
IFileContainer fileContainer = templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.ResolveFile(fileName);
templateParsingState.WebConnection.TouchedFiles.Add(fileContainer);
// If the user doesn't have permission for the component and the component has something to use instead, use it
if (null == fileContainer.LoadPermission(templateParsingState.WebConnection.Session.User.Id) && element.HasChildNodes)
{
XmlNode replacement = element.OwnerDocument.CreateElement("div");
foreach (XmlNode errorNode in element.ChildNodes)
replacement.AppendChild(errorNode);
element.ParentNode.InsertAfter(replacement, element);
element.ParentNode.RemoveChild(element);
}
else
{
// If the user has permission, resolve the component and deal with default errors
XmlDocument snipitDocument = new XmlDocument();
// TODO: GET Parameters
try
{
snipitDocument.LoadXml(string.Format(
"<div xmlns=\"{0}\" xmlns:oc=\"{1}\">{2}</div>",
templateParsingState.TemplateDocument.FirstChild.NamespaceURI,
templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace,
fileContainer.CastFileHandler<ITextHandler>().ReadAll()));
XmlNodeList replacementNodes = snipitDocument.FirstChild.ChildNodes;
templateParsingState.SetCWD(replacementNodes, fileContainer.ParentDirectoryHandler.FileContainer.FullPath);
templateParsingState.ReplaceNodes(element, replacementNodes);
}
catch (WebResultsOverrideException wroe)
{
templateParsingState.ReplaceNodes(
element,
templateParsingState.GenerateWarningNode(wroe.WebResults.ResultsAsString));
}
catch (Exception e)
{
log.Error("An error occured when loading a component", e);
templateParsingState.ReplaceNodes(
element,
templateParsingState.GenerateWarningNode("An unhandled error occured. See the system logs for more information"));
}
}
}
}
