private static void ReadRule(XmlNode node, IRewriterConfiguration config) { var parsed = false; var parsers = config.ActionParserFactory.GetParsers(node.LocalName); if (parsers != null) { foreach (var parser in parsers) { if (!parser.AllowsNestedActions && node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, parser.Name), node); } if (!parser.AllowsAttributes && node.Attributes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoAttributes, parser.Name), node); } var rule = parser.Parse(node, config); if (rule != null) { config.Rules.Add(rule); parsed = true; break; } } } if (!parsed) { // No parsers recognised to handle this node. throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, node.LocalName), node); } }
private static void ReadMapping(XmlNode node, IRewriterConfiguration config) { // Name attribute. var mappingName = node.GetRequiredAttribute(Constants.AttrName); // Mapper type not specified. Load in the hash map. var map = new StringDictionary(); foreach (XmlNode mapNode in node.ChildNodes) { if (mapNode.NodeType == XmlNodeType.Element) { if (mapNode.LocalName == Constants.ElementMap) { var fromValue = mapNode.GetRequiredAttribute(Constants.AttrFrom, true); var toValue = mapNode.GetRequiredAttribute(Constants.AttrTo, true); map.Add(fromValue, toValue); } else { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, mapNode.LocalName), node); } } } IRewriteTransform mapping = new StaticMappingTransform(mappingName, map); config.TransformFactory.Add(mapping); }
private static void ReadErrorHandler(XmlNode node, IRewriterConfiguration config) { var code = node.GetRequiredAttribute(Constants.AttrCode); XmlNode typeNode = node.Attributes[Constants.AttrType]; XmlNode urlNode = node.Attributes[Constants.AttrUrl]; if (typeNode == null && urlNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node); } IRewriteErrorHandler handler; if (typeNode != null) { // <error-handler code="500" url="/oops.aspx" /> handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler; if (handler == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified, typeNode.Value, typeof(IRewriteErrorHandler)), node); } } else { handler = new DefaultErrorHandler(urlNode.Value); } if (!int.TryParse(code, out var statusCode)) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidHttpStatusCode, code), node); } config.ErrorHandlers.Add(statusCode, handler); }
private const int MaxRestarts = 10; // Controls the number of restarts so we don't get into an infinite loop /// <summary> /// Constructor. /// </summary> /// <param name="httpContext">The HTTP context facade.</param> /// <param name="configurationManager">The configuration manager facade.</param> /// <param name="configuration">The URL rewriter configuration.</param> public RewriterEngine( IHttpContext httpContext, IConfigurationManager configurationManager, IRewriterConfiguration configuration) { this._httpContext = httpContext ?? throw new ArgumentNullException(nameof(httpContext)); this._configurationManager = configurationManager ?? throw new ArgumentNullException(nameof(configurationManager)); this._configuration = configuration ?? throw new ArgumentNullException(nameof(configuration)); }
private static void ReadDefaultDocuments(XmlNode node, IRewriterConfiguration config) { node.ChildNodes.Cast <XmlNode>().ForEach(childNode => { if (childNode.NodeType == XmlNodeType.Element && childNode.LocalName == Constants.ElementDocument) { config.DefaultDocuments.Add(childNode.InnerText); } }); }
private static void ReadDefaultDocuments(XmlNode node, IRewriterConfiguration config) { foreach (XmlNode childNode in node.ChildNodes) { if (childNode.NodeType == XmlNodeType.Element && childNode.LocalName == Constants.ElementDocument) { config.DefaultDocuments.Add(childNode.InnerText); } } }
public void Constructor_WithNullConfiguration_Throws() { // Arrange XmlNode emptySection = CreateEmptyXmlNode(); IHttpContext httpContext = null; IConfigurationManager configurationManager = new MockConfigurationManager(emptySection); IRewriterConfiguration configuration = null; // Act/Assert ExceptionAssert.Throws <ArgumentNullException>(() => new RewriterEngine(httpContext, configurationManager, configuration)); }
/// <summary> /// Reads configuration information from the given XML Node. /// </summary> /// <param name="config">The rewriter configuration object to populate.</param> /// <param name="section">The XML node to read configuration from.</param> /// <returns>The configuration information.</returns> public static void Read(IRewriterConfiguration config, XmlNode section) { if (section == null) { throw new ArgumentNullException("section"); } foreach (XmlNode node in section.ChildNodes) { if (node.NodeType != XmlNodeType.Element) { continue; } switch (node.LocalName) { case Constants.ElementErrorHandler: ReadErrorHandler(node, config); break; case Constants.ElementDefaultDocuments: ReadDefaultDocuments(node, config); break; case Constants.ElementRegister when node.Attributes[Constants.AttrParser] != null: ReadRegisterParser(node, config); break; case Constants.ElementRegister when node.Attributes[Constants.AttrTransform] != null: ReadRegisterTransform(node, config); break; case Constants.ElementRegister: { if (node.Attributes[Constants.AttrLogger] != null) { ReadRegisterLogger(node, config); } break; } case Constants.ElementMapping: ReadMapping(node, config); break; default: ReadRule(node, config); break; } } }
/// <summary> /// Parses conditions from the node. /// </summary> /// <param name="node">The node.</param> /// <param name="conditions">Conditions list to add new conditions to.</param> /// <param name="negative">Whether the conditions should be negated.</param> /// <param name="config">Rewriter configuration</param> protected void ParseConditions(XmlNode node, IList<IRewriteCondition> conditions, bool negative, IRewriterConfiguration config) { if (config == null) { return; } if (node == null) { throw new ArgumentNullException("node"); } if (conditions == null) { throw new ArgumentNullException("conditions"); } // Parse attribute-based conditions. foreach (IRewriteConditionParser parser in config.ConditionParserPipeline) { IRewriteCondition condition = parser.Parse(node); if (condition != null) { if (negative) { condition = new NegativeCondition(condition); } conditions.Add(condition); } } // Now, process the nested <and> conditions. XmlNode childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { if (childNode.LocalName == Constants.ElementAnd) { ParseConditions(childNode, conditions, negative, config); XmlNode childNode2 = childNode.NextSibling; node.RemoveChild(childNode); childNode = childNode2; continue; } } childNode = childNode.NextSibling; } }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } string to = node.GetRequiredAttribute(Constants.AttrTo, true); bool permanent = node.GetBooleanAttribute(Constants.AttrPermanent) ?? true; RedirectAction action = new RedirectAction(to, permanent); ParseConditions(node, action.Conditions, false, config); return action; }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException(nameof(node)); } var to = node.GetRequiredAttribute(Constants.AttrTo, true); var permanent = node.GetBooleanAttribute(Constants.AttrPermanent) ?? true; var action = new RedirectAction(to, permanent); this.ParseConditions(node, action.Conditions, false, config); return(action); }
private static void ReadRegisterLogger(XmlNode node, IRewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } var type = node.GetRequiredAttribute(Constants.AttrLogger); // Logger type specified. Create an instance and add it // as the mapper handler for this map. if (TypeHelper.Activate(type, null) is IRewriteLogger logger) { config.Logger = logger; } }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string propertyName = node.GetRequiredAttribute(Constants.AttrProperty); string appSettingKey = node.GetRequiredAttribute(Constants.AttrKey); return new SetAppSettingPropertyAction(propertyName, appSettingKey); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string propertyName = node.GetRequiredAttribute(Constants.AttrProperty); string appSettingKey = node.GetRequiredAttribute(Constants.AttrKey); return(new SetAppSettingPropertyAction(propertyName, appSettingKey)); }
/// <summary> /// Reads configuration information from the given XML Node. /// </summary> /// <param name="config">The rewriter configuration object to populate.</param> /// <param name="section">The XML node to read configuration from.</param> /// <returns>The configuration information.</returns> public static void Read(IRewriterConfiguration config, XmlNode section) { if (section == null) { throw new ArgumentNullException("section"); } foreach (XmlNode node in section.ChildNodes) { if (node.NodeType == XmlNodeType.Element) { if (node.LocalName == Constants.ElementErrorHandler) { ReadErrorHandler(node, config); } else if (node.LocalName == Constants.ElementDefaultDocuments) { ReadDefaultDocuments(node, config); } else if (node.LocalName == Constants.ElementRegister) { if (node.Attributes[Constants.AttrParser] != null) { ReadRegisterParser(node, config); } else if (node.Attributes[Constants.AttrTransform] != null) { ReadRegisterTransform(node, config); } else if (node.Attributes[Constants.AttrLogger] != null) { ReadRegisterLogger(node, config); } } else if (node.LocalName == Constants.ElementMapping) { ReadMapping(node, config); } else { ReadRule(node, config); } } } }
private static void ReadRegisterTransform(XmlNode node, IRewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } var type = node.GetRequiredAttribute(Constants.AttrTransform); // Transform type specified. // Create an instance and add it as the mapper handler for this map. if (!(TypeHelper.Activate(type, null) is IRewriteTransform transform)) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified, type, typeof(IRewriteTransform)), node); } config.TransformFactory.Add(transform); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } int? statusCode = node.GetIntegerAttribute(Constants.AttrStatus); if (!statusCode.HasValue) { return null; } return new SetStatusAction((HttpStatusCode)statusCode.Value); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } int?statusCode = node.GetIntegerAttribute(Constants.AttrStatus); if (!statusCode.HasValue) { return(null); } return(new SetStatusAction((HttpStatusCode)statusCode.Value)); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string to = node.GetRequiredAttribute(Constants.AttrTo, true); RewriteProcessing processing = ParseProcessing(node); RewriteAction action = new RewriteAction(to, processing); ParseConditions(node, action.Conditions, false, config); return action; }
private static void ReadRegisterParser(XmlNode node, IRewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } var type = node.GetRequiredAttribute(Constants.AttrParser); var parser = TypeHelper.Activate(type, null); if (parser is IRewriteActionParser actionParser) { config.ActionParserFactory.Add(actionParser); } if (parser is IRewriteConditionParser conditionParser) { config.ConditionParserPipeline.Add(conditionParser); } }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } var to = node.GetRequiredAttribute(Constants.AttrTo, true); var processing = ParseProcessing(node); var action = new RewriteAction(to, processing); ParseConditions(node, action.Conditions, false, config); return(action); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string cookieName = node.GetOptionalAttribute(Constants.AttrCookie); if (String.IsNullOrEmpty(cookieName)) { return null; } string cookieValue = node.GetRequiredAttribute(Constants.AttrValue, true); return new SetCookieAction(cookieName, cookieValue); }
/// <summary> /// Constructor. /// </summary> /// <param name="httpContext">The HTTP context facade.</param> /// <param param name="configurationManager">The configuration manager facade.</param> /// <param name="configuration">The URL rewriter configuration.</param> public RewriterEngine( IHttpContext httpContext, IConfigurationManager configurationManager, IRewriterConfiguration configuration) { if (httpContext == null) { throw new ArgumentNullException("httpContext"); } if (configurationManager == null) { throw new ArgumentNullException("configurationManager"); } if (configuration == null) { throw new ArgumentNullException("configuration"); } _httpContext = httpContext; _configurationManager = configurationManager; _configuration = configuration; }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string headerName = node.GetOptionalAttribute(Constants.AttrHeader); if (headerName == null) { return null; } string headerValue = node.GetRequiredAttribute(Constants.AttrValue, true); return new AddHeaderAction(headerName, headerValue); }
/// <summary> /// Parses the action. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } ConditionalAction rule = new ConditionalAction(); // Process the conditions on the element. bool negative = (node.LocalName == Constants.ElementUnless); ParseConditions(node, rule.Conditions, negative, config); // Next, process the actions on the element. ReadActions(node, rule.Actions, config); return rule; }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } var headerName = node.GetOptionalAttribute(Constants.AttrHeader); if (headerName == null) { return(null); } var headerValue = node.GetRequiredAttribute(Constants.AttrValue, true); return(new AddHeaderAction(headerName, headerValue)); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } string cookieName = node.GetOptionalAttribute(Constants.AttrCookie); if (String.IsNullOrEmpty(cookieName)) { return(null); } string cookieValue = node.GetRequiredAttribute(Constants.AttrValue, true); return(new SetCookieAction(cookieName, cookieValue)); }
/// <summary> /// Parses the action. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException("node"); } if (config == null) { throw new ArgumentNullException("config"); } var rule = new ConditionalAction(); // Process the conditions on the element. var negative = (node.LocalName == Constants.ElementUnless); ParseConditions(node, rule.Conditions, negative, config); // Next, process the actions on the element. ReadActions(node, rule.Actions, config); return(rule); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { if (node == null) { throw new ArgumentNullException(nameof(node)); } if (config == null) { throw new ArgumentNullException(nameof(config)); } var propertyName = node.GetOptionalAttribute(Constants.AttrProperty); if (propertyName.IsNotSet()) { return(null); } var propertyValue = node.GetRequiredAttribute(Constants.AttrValue, true); return(new SetPropertyAction(propertyName, propertyValue)); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { return new GoneAction(); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { return new MethodNotAllowedAction(); }
private static void ReadErrorHandler(XmlNode node, IRewriterConfiguration config) { string code = node.GetRequiredAttribute(Constants.AttrCode); XmlNode typeNode = node.Attributes[Constants.AttrType]; XmlNode urlNode = node.Attributes[Constants.AttrUrl]; if (typeNode == null && urlNode == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.AttributeRequired, Constants.AttrUrl), node); } IRewriteErrorHandler handler = null; if (typeNode != null) { // <error-handler code="500" url="/oops.aspx" /> handler = TypeHelper.Activate(typeNode.Value, null) as IRewriteErrorHandler; if (handler == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified, typeNode.Value, typeof(IRewriteErrorHandler)), node); } } else { handler = new DefaultErrorHandler(urlNode.Value); } int statusCode; if (!Int32.TryParse(code, out statusCode)) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidHttpStatusCode, code), node); } config.ErrorHandlers.Add(statusCode, handler); }
/// <summary> /// Parses conditions from the node. /// </summary> /// <param name="node">The node.</param> /// <param name="conditions">Conditions list to add new conditions to.</param> /// <param name="negative">Whether the conditions should be negated.</param> /// <param name="config">Rewriter configuration</param> protected void ParseConditions(XmlNode node, IList <IRewriteCondition> conditions, bool negative, IRewriterConfiguration config) { if (config == null) { return; } if (node == null) { throw new ArgumentNullException("node"); } if (conditions == null) { throw new ArgumentNullException("conditions"); } // Parse attribute-based conditions. foreach (var parser in config.ConditionParserPipeline) { var condition = parser.Parse(node); if (condition != null) { if (negative) { condition = new NegativeCondition(condition); } conditions.Add(condition); } } // Now, process the nested <and> conditions. var childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { if (childNode.LocalName == Constants.ElementAnd) { this.ParseConditions(childNode, conditions, negative, config); var childNode2 = childNode.NextSibling; node.RemoveChild(childNode); childNode = childNode2; continue; } } childNode = childNode.NextSibling; } }
private static void ReadActions(XmlNode node, ICollection <IRewriteAction> actions, IRewriterConfiguration config) { var childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { var parsers = config.ActionParserFactory.GetParsers(childNode.LocalName); if (parsers != null) { var parsed = false; foreach (var parser in parsers) { var action = parser.Parse(childNode, config); if (action == null) { continue; } parsed = true; actions.Add(action); } if (!parsed) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, node.FirstChild.Name), node); } } } childNode = childNode.NextSibling; } }
/// <summary> /// Parses the action. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, null if no action parsed.</returns> public abstract IRewriteAction Parse(XmlNode node, IRewriterConfiguration config);
private static void ReadRegisterTransform(XmlNode node, IRewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrTransform); // Transform type specified. // Create an instance and add it as the mapper handler for this map. IRewriteTransform transform = TypeHelper.Activate(type, null) as IRewriteTransform; if (transform == null) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.InvalidTypeSpecified, type, typeof(IRewriteTransform)), node); } config.TransformFactory.Add(transform); }
private static void ReadActions(XmlNode node, IList<IRewriteAction> actions, IRewriterConfiguration config) { XmlNode childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { IList<IRewriteActionParser> parsers = config.ActionParserFactory.GetParsers(childNode.LocalName); if (parsers != null) { bool parsed = false; foreach (IRewriteActionParser parser in parsers) { IRewriteAction action = parser.Parse(childNode, config); if (action != null) { parsed = true; actions.Add(action); } } if (!parsed) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, node.FirstChild.Name), node); } } } childNode = childNode.NextSibling; } }
private static void ReadRegisterLogger(XmlNode node, IRewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrLogger); // Logger type specified. Create an instance and add it // as the mapper handler for this map. IRewriteLogger logger = TypeHelper.Activate(type, null) as IRewriteLogger; if (logger != null) { config.Logger = logger; } }
private static void ReadRegisterParser(XmlNode node, IRewriterConfiguration config) { if (node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, Constants.ElementRegister), node); } string type = node.GetRequiredAttribute(Constants.AttrParser); object parser = TypeHelper.Activate(type, null); IRewriteActionParser actionParser = parser as IRewriteActionParser; if (actionParser != null) { config.ActionParserFactory.Add(actionParser); } IRewriteConditionParser conditionParser = parser as IRewriteConditionParser; if (conditionParser != null) { config.ConditionParserPipeline.Add(conditionParser); } }
private static void ReadMapping(XmlNode node, IRewriterConfiguration config) { // Name attribute. string mappingName = node.GetRequiredAttribute(Constants.AttrName); // Mapper type not specified. Load in the hash map. StringDictionary map = new StringDictionary(); foreach (XmlNode mapNode in node.ChildNodes) { if (mapNode.NodeType == XmlNodeType.Element) { if (mapNode.LocalName == Constants.ElementMap) { string fromValue = mapNode.GetRequiredAttribute(Constants.AttrFrom, true); string toValue = mapNode.GetRequiredAttribute(Constants.AttrTo, true); map.Add(fromValue, toValue); } else { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, mapNode.LocalName), node); } } } IRewriteTransform mapping = new StaticMappingTransform(mappingName, map); config.TransformFactory.Add(mapping); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { return(new NotImplementedAction()); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { return(new ForbiddenAction()); }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { return(new MethodNotAllowedAction()); }
private static void ReadRule(XmlNode node, IRewriterConfiguration config) { bool parsed = false; IList<IRewriteActionParser> parsers = config.ActionParserFactory.GetParsers(node.LocalName); if (parsers != null) { foreach (IRewriteActionParser parser in parsers) { if (!parser.AllowsNestedActions && node.ChildNodes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoElements, parser.Name), node); } if (!parser.AllowsAttributes && node.Attributes.Count > 0) { throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNoAttributes, parser.Name), node); } IRewriteAction rule = parser.Parse(node, config); if (rule != null) { config.Rules.Add(rule); parsed = true; break; } } } if (!parsed) { // No parsers recognised to handle this node. throw new ConfigurationErrorsException(MessageProvider.FormatString(Message.ElementNotAllowed, node.LocalName), node); } }
/// <summary> /// Parses the node. /// </summary> /// <param name="node">The node to parse.</param> /// <param name="config">The rewriter configuration.</param> /// <returns>The parsed action, or null if no action parsed.</returns> public override IRewriteAction Parse(XmlNode node, IRewriterConfiguration config) { return new NotImplementedAction(); }