/// <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; } }
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); }
/// <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; }
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")); } } } }
private void LoadComponent( ITemplateParsingState templateParsingState, IDictionary<string, object> getParameters, XmlElement element) { XmlAttribute srcAttribute = (XmlAttribute)element.Attributes.GetNamedItem("src", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace); XmlAttribute urlAttribute = (XmlAttribute)element.Attributes.GetNamedItem("url", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace); // handle GET parameters // First, handle oc:getpassthrough IDictionary<string, object> myGetParameters; XmlAttribute getpassthroughAttribute = (XmlAttribute)element.Attributes.GetNamedItem("getpassthough", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace); if (null == getpassthroughAttribute) { myGetParameters = DictionaryFunctions.Create<string, object>(getParameters); myGetParameters.Remove("Method"); myGetParameters.Remove("Action"); } else { if ("false" == getpassthroughAttribute.Value) myGetParameters = new Dictionary<string, object>(); else { myGetParameters = DictionaryFunctions.Create<string, object>(getParameters); myGetParameters.Remove("Method"); myGetParameters.Remove("Action"); } } // Next, pull out get parameters from the tag foreach (XmlAttribute attribute in element.Attributes) if ("" == attribute.NamespaceURI) myGetParameters[attribute.LocalName] = attribute.Value; if ((null == srcAttribute) && (null == urlAttribute)) // Remove empty components element.ParentNode.RemoveChild(element); else if ((null != srcAttribute) && (null != urlAttribute)) templateParsingState.ReplaceNodes( element, templateParsingState.GenerateWarningNode("Either oc:src or oc:url can be specified; you can not choose both: " + element.OuterXml)); else if (null != srcAttribute) { string fileName = templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.GetAbsolutePath( templateParsingState.GetCWD(element), srcAttribute.Value); IFileContainer fileContainer; try { fileContainer = templateParsingState.FileHandlerFactoryLocator.FileSystemResolver.ResolveFile(fileName); } catch (FileDoesNotExist fdne) { log.Warn("An attempt was made to use a non-existant file in a template", fdne); templateParsingState.ReplaceNodes( element, templateParsingState.GenerateWarningNode(fileName + " not found")); return; } 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 componentDocument; // TODO: GET Parameters try { componentDocument = templateParsingState.LoadXmlDocumentAndReplaceGetParameters( myGetParameters, fileContainer, templateParsingState.GetXmlParseMode(element)); XmlNode firstChild = componentDocument.FirstChild; XmlNodeList replacementNodes; if ((firstChild.LocalName == "componentdef") && (firstChild.NamespaceURI == templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace)) replacementNodes = firstChild.ChildNodes; else replacementNodes = componentDocument.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")); } } } else if (null != urlAttribute) { XmlNode resultNode; string url = urlAttribute.Value; foreach (KeyValuePair<string, object> getParameter in myGetParameters) url = HTTPStringFunctions.AppendGetParameter(url, getParameter.Key, getParameter.Value.ToString()); try { if (url.StartsWith("https://")) resultNode = templateParsingState.GenerateWarningNode("https component nodes aren't supported due to certificate complexities"); else if (url.StartsWith("http://")) { HttpResponseHandler httpResponse = templateParsingState.WebConnection.Session.HttpWebClient.Get(url); if ("text/xml" == httpResponse.ContentType) resultNode = templateParsingState.LoadXmlDocument("<html xmlns=\"" + templateParsingState.TemplateHandlerLocator.TemplatingConstants.HtmlNamespace + "\"><head></head><body>" + httpResponse.AsString() + "</body></html>", XmlParseMode.Xml, templateParsingState.GetCWD(element)).FirstChild.ChildNodes[1]; else resultNode = element.OwnerDocument.CreateTextNode(httpResponse.AsString()); } else try { ShellWebConnection shellWebConnection = new BlockingShellWebConnection( url, templateParsingState.WebConnection, null, templateParsingState.WebConnection.CookiesFromBrowser); IWebResults shellResults = shellWebConnection.GenerateResultsForClient(); if ("text/xml" == shellResults.ContentType) resultNode = templateParsingState.LoadXmlDocument("<html xmlns=\"" + templateParsingState.TemplateHandlerLocator.TemplatingConstants.HtmlNamespace + "\"><head></head><body>" + shellResults.ResultsAsString + "</body></html>", XmlParseMode.Xml, templateParsingState.GetCWD( element)).FirstChild.ChildNodes[1]; else resultNode = element.OwnerDocument.CreateTextNode(shellResults.ResultsAsString); } catch (WebResultsOverrideException wroe) { resultNode = templateParsingState.GenerateWarningNode(wroe.WebResults.ResultsAsString); } } catch (Exception e) { log.Error("An error occured when loading a component", e); resultNode = templateParsingState.GenerateWarningNode("An unhandled error occured. See the system logs for more information"); } templateParsingState.ReplaceNodes(element, resultNode); } }