public void NotWord() { var context = new ConditionContext("!"); ConditionParser.Tokenise(context); Assert.IsType <Not>(context.Values.First()); }
private Expression HandleContains(StringOperatorCondition <T> p_Condition, ConditionContext p_Context) { return((Expression)Expression.Call(this.GetFieldExpression(p_Context.ParameterExpression, this.m_Condition), "Contains", (Type[])null, new Expression[1] { this.GetConstantExpression(p_Context.ParameterExpression, this.m_Condition) })); }
public void Groups() { var context = new ConditionContext("()"); ConditionParser.Tokenise(context); Assert.Equal(2, context.Values.Count); }
public Expression <Func <T, bool> > GetFilterExpression <T>(IEnumerable <string> values) where T : SearchResultItem { int year = ValidateInput(values.FirstOrDefault()); // abort if input is no good if (year == 0) { return(null); } DateTime startTime = new DateTime(year, 1, 1); DateTime endTime = new DateTime(year, 12, 31); ParameterExpression expression = Expression.Parameter(typeof(T), "item"); ConditionContext context = new ConditionContext(expression); var greaterThan = new Func <Expression, Expression, Expression>(Expression.GreaterThanOrEqual); var lessThan = new Func <Expression, Expression, Expression>(Expression.LessThanOrEqual); var dateRangeExpression = Expression.Lambda <Func <T, bool> >(greaterThan(Expression.Property(context.ParameterExpression, typeof(T), SearchResultItemUtil.GetPropertyName <T>(InnerItem.Field_Name)), Expression.Constant(startTime)), new[] { expression }); dateRangeExpression = Expression.Lambda <Func <T, bool> >(lessThan(Expression.Property(context.ParameterExpression, typeof(T), SearchResultItemUtil.GetPropertyName <T>(InnerItem.Field_Name)), Expression.Constant(endTime)), new[] { expression }); return(dateRangeExpression); }
public Expression <Func <T, bool> > GetFilterExpression <T>(IEnumerable <string> values) where T : SearchResultItem { DateTime startDate = DateTime.MinValue; DateTime endDate = DateTime.MinValue; DateTime.TryParse(values.First(), out startDate); DateTime.TryParse(values.Last(), out endDate); // lets make sure items are within the day. if (endDate > DateTime.MinValue) { endDate = endDate.AddHours(23); endDate = endDate.AddMinutes(59); endDate = endDate.AddSeconds(59); } ParameterExpression expression = Expression.Parameter(typeof(T), "item"); ConditionContext context = new ConditionContext(expression); var greaterThan = new Func <Expression, Expression, Expression>(Expression.GreaterThanOrEqual); var lessThan = new Func <Expression, Expression, Expression>(Expression.LessThanOrEqual); var dateRangeExpression = Expression.Lambda <Func <T, bool> >(greaterThan(Expression.Property(context.ParameterExpression, typeof(T), SearchResultItemUtil.GetPropertyName <T>(InnerItem.Field_Name)), Expression.Constant(startDate)), new[] { expression }); if (endDate > DateTime.MinValue) { dateRangeExpression = dateRangeExpression.And(Expression.Lambda <Func <T, bool> >(lessThan(Expression.Property(context.ParameterExpression, typeof(T), SearchResultItemUtil.GetPropertyName <T>(InnerItem.Field_Name)), Expression.Constant(endDate)), new[] { expression })); } return(dateRangeExpression); }
public override Expression GetQueryExpression(ConditionContext p_Context) { return(Expression.Call(this.GetTypedFieldValueExpression(p_Context), "Contains", (Type[])null, new Expression[1] { this.GetTypedValueExpression(p_Context) })); }
/// <summary> /// Determines whether or not a rule should execute. /// </summary> /// <param name="rule">The rule</param> /// <param name="propertyPath">Property path (eg Customer.Address.Line1)</param> /// <param name="context">Contextual information</param> /// <returns>Whether or not the validator can execute.</returns> public bool CanExecute(IPropertyRule rule, string propertyPath, ConditionContext context) { // By default we ignore any rules part of a RuleSet. // TODO //if (!string.IsNullOrEmpty(rule.RuleSet)) return false; return true; }
private Expression HandleMatchRegex(StringOperatorCondition <T> p_Condition, ConditionContext p_Context) { return((Expression)Expression.Call((Expression)null, typeof(MethodExtensions).GetMethod("Matches", new Type[2] { typeof(string), typeof(string) }), this.GetFieldExpression(p_Context.ParameterExpression, this.m_Condition), this.GetConstantExpression(p_Context.ParameterExpression, this.m_Condition))); }
/********* ** Public methods *********/ /// <summary>Construct an instance.</summary> /// <param name="monitor">Encapsulates monitoring and logging.</param> /// <param name="conditionFactory">Handles constructing, permuting, and updating conditions.</param> /// <param name="verboseLog">Whether to enable verbose logging.</param> /// <param name="normaliseAssetName">Normalise an asset name.</param> /// <param name="language">The current language.</param> public PatchManager(IMonitor monitor, ConditionFactory conditionFactory, bool verboseLog, Func <string, string> normaliseAssetName, LocalizedContentManager.LanguageCode language) { this.Monitor = monitor; this.ConditionFactory = conditionFactory; this.ConditionContext = conditionFactory.BuildContext(language); this.Verbose = verboseLog; this.NormaliseAssetName = normaliseAssetName; }
public void OrSymbol() { var context = new ConditionContext("||"); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <Or>(value); }
public void GreaterThanWord() { var context = new ConditionContext(" is greater than "); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <GreaterThan>(value); }
public void EqualSymbol() { var context = new ConditionContext("=="); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <Equal>(value); }
public void LessThanSymbol() { var context = new ConditionContext("<"); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <LessThan>(value); }
public void NotEqualWord() { var context = new ConditionContext(" is not "); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <NotEqual>(value); }
public void AndWord() { var context = new ConditionContext(" and "); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <And>(value); }
public void LessThanEqualWord() { var context = new ConditionContext(" is less than or equal "); ConditionParser.Tokenise(context); var value = Assert.Single(context.Values); Assert.IsType <LessThanEqual>(value); }
/// <summary> /// Tries the process. /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public bool TryExecute(RuleContext context) { // check if this rule should be run if (Action.IsMatch(context)) { Manager.LogIf(context.LogLevel >= 2, "Rule Pattern Matched", context.LogCategory); bool skipOrNext = false; string[] conditionValues = new string[_conditions.Count]; // test to make sure all conditions are met for (int i = 0; i < _conditions.Count; i++) { ConditionContext conditionContext = new ConditionContext(i, context, _conditions[i]); bool containsOrNext = ConditionFlagsProcessor.HasOrNext(_conditions[i].Flags); bool previousContainsOrNext = ConditionFlagsProcessor.HasOrNext(_conditions[Math.Max(0, i - 1)].Flags); if (skipOrNext && (previousContainsOrNext || containsOrNext)) { continue; } else { skipOrNext = false; } // test the condition if it fails and then terminate if (!_conditions[i].Evaluate(conditionContext)) { if (containsOrNext) { continue; } else { return(false); } } else if (containsOrNext) { skipOrNext = true; } } // call an external method that might want to inherit from this rule implimentation OnExecuting(context); // process the substition for the pattern Action.Execute(context); // the pattern matched return(true); } // the pattern did not match return(false); }
/// <summary> /// Evaluates the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { string test = Test.GetValue(context); // get the pattern with out the special character string pattern = Pattern.ToString().Substring(1); bool comparison = String.Compare(test, pattern, ConditionFlagsProcessor.HasNoCase(context.ConditionFlags)) > 0; return Pattern.InvertMatch ? !comparison : comparison; }
public override bool Equals(object obj) { ConditionContext that = obj as ConditionContext; if (ReferenceEquals(that, null)) { return(false); } return(EnumerableExtensions.AreEqual(this.blocks, that.blocks)); }
public ConditionContext GetParentContext() { if (blocks.Count == 1) { return(null); } ConditionContext parent = new ConditionContext(); parent.blocks.AddRange(blocks.Take(blocks.Count - 1)); return(parent); }
/// <summary> /// Evaluates the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { string test = Test.GetValue(context); // get the pattern with out the special character string pattern = Pattern.ToString().Substring(1); bool comparison = String.Compare(test, pattern, ConditionFlagsProcessor.HasNoCase(context.ConditionFlags)) == 0; return(Pattern.InvertMatch ? !comparison : comparison); }
private void SetSearch(FilterconditionContext filter, string name, string varName) { if (filter != null) { var dq = new DataCube(name, DataStatement.SEARCH, varName); ConditionContext condition = filter.condition(); var search = new State.Search(condition.children[0].GetText(), condition.children[1].GetText(), condition.children[2].GetText()); dq.SearchStatement = (search); DataCubes.Add(dq); } }
private bool CheckCondition(ConditionContext condition) { ValidateChildCount(condition, 3); object result = Interpret(condition.GetChild(1)); if (result is bool boolResult) { return(boolResult); } throw new InterpreterException(condition, "Condition should be evaluated to boolean, not " + result.GetType()); }
/// <summary> /// Determines whether the specified log level is match. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { bool isMatch = false; string test = Test.GetValue(context); // pattern handles its own invert if needed isMatch = _pattern.IsMatch(test, context); Manager.LogIf(context.LogLevel >= 2, isMatch ? " Matched" : " Not Matched", context.LogCategory); return(isMatch); }
public void TestPredicateCondition() { string newValue = "bcd"; PropertyRule rule = PropertyRule.Create<TestModel, string>(e => e.StrProperty); Func<TestModel, bool> predicate = e => e.StrProperty != null; rule.AddCondition(new PredicateCondition(predicate.CoerceToNonGeneric())); rule.Assign(e => newValue); TestModel model = new TestModel(); ConditionContext context = new ConditionContext(model); rule.Set(context); Assert.AreNotEqual(model.StrProperty, newValue); }
/// <summary> /// Creates the condition execution context. /// </summary> /// <returns></returns> public ConditionContext CreateOutputConditionContext(Uri requestedUrl, byte[] responseContent) { // create properties var condition = new Mock <ICondition>().Object; // setup object var ruleContext = CreateOutputRuleContext(requestedUrl, responseContent); var conditionContext = new ConditionContext(0, ruleContext, condition); // return object return(conditionContext); }
/// <summary> /// Creates the condition execution context. /// </summary> /// <returns></returns> public ConditionContext CreateConditionContext(Uri requestedUrl) { // create properties var condition = new Mock <ICondition>().Object; // setup object var ruleContext = CreateRuleContext(requestedUrl); var conditionContext = new ConditionContext(0, ruleContext, condition); // return object return(conditionContext); }
public override Expression GetQueryExpression(ConditionContext p_Context) { StringOperatorCondition <T> p_Condition = this.Condition as StringOperatorCondition <T>; Assert.IsNotNull((object)p_Condition, "Condition has the wrong type. Type \"{0}\" is expected.", new object[1] { (object)typeof(StringOperatorCondition <T>).FullName }); Expression expression; switch (p_Condition.OperatorId) { case "{2E67477C-440C-4BCA-A358-3D29AED89F47}": expression = this.HandleContains(p_Condition, p_Context); break; case "{22E1F05F-A17A-4D0C-B376-6F7661500F03}": expression = this.HandleEndsWith(p_Condition, p_Context); break; case "{10537C58-1684-4CAB-B4C0-40C10907CE31}": expression = this.HandleEquals(p_Condition, p_Context); break; case "{537244C2-3A3F-4B81-A6ED-02AF494C0563}": expression = this.HandleEqualsCaseInsensitive(p_Condition, p_Context); break; case "{F8641C26-EE27-483C-9FEA-35529ECC8541}": expression = this.HandleMatchRegex(p_Condition, p_Context); break; case "{A6AC5A6B-F409-48B0-ACE7-C3E8C5EC6406}": expression = this.HandleNotEqual(p_Condition, p_Context); break; case "{6A7294DF-ECAE-4D5F-A8D2-C69CB1161C09}": expression = this.HandleNotEqualCaseInsensitive(p_Condition, p_Context); break; case "{FDD7C6B1-622A-4362-9CFF-DDE9866C68EA}": expression = this.HandleStartsWith(p_Condition, p_Context); break; default: StringConditionWrapper <T, TCondition> .s_Logger.Debug(string.Format("Unknown operator id \"{0}\". Returning true expression.", (object)p_Condition.OperatorId)); expression = (Expression)Expression.Constant((object)true); break; } return(expression); }
public void TestMethod1() { string newValue = "bcd"; PropertyRule rule = PropertyRule.Create<TestModel, string>(e => e.StrProperty); rule.Assign(e => newValue); TestModel model = new TestModel(); ConditionContext context = new ConditionContext(model); rule.Set(context); Assert.AreEqual(model.StrProperty, newValue); // // TODO: Add test logic here // }
/// <summary> /// Evaluates the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { string test = Test.GetValue(context); if (String.IsNullOrEmpty(test)) return false; if (!test.StartsWith(HttpRuntime.AppDomainAppPath) && !test.Contains(":")) test = context.HttpContext.Server.MapPath(test); bool exists = File.Exists(test); return Pattern.InvertMatch ? !exists : exists; }
public void EqualityCheck() { var context = new ConditionContext("defeated == false"); ConditionParser.Tokenise(context); Assert.Equal(3, context.Values.Count); var values = context.Values.ToList(); Assert.IsType <LiteralValue>(values[0]); Assert.IsType <Equal>(values[1]); Assert.IsType <Variable>(values[2]); }
public void MultipleChecksWithSymbols() { var context = new ConditionContext("defeated == false && 5 >= 3"); ConditionParser.Tokenise(context); Assert.Equal(7, context.Values.Count); var values = context.Values.Reverse().ToList(); Assert.IsType <Variable>(values[0]); Assert.IsType <Equal>(values[1]); Assert.IsType <LiteralValue>(values[2]); Assert.IsType <And>(values[3]); Assert.IsType <LiteralValue>(values[4]); Assert.IsType <GreaterThanEqual>(values[5]); Assert.IsType <LiteralValue>(values[6]); }
public Expression <Func <T, bool> > GetQueryExpression <T, TK>(IEnumerable <ISearchCondition <TK> > conditions) where T : SearchResultItem where TK : RuleContext { Expression <Func <T, bool> > predicate = null; if (conditions.Any()) { ParameterExpression expression = Expression.Parameter(typeof(T), "item"); ConditionContext context = new ConditionContext(expression); foreach (ISearchCondition <TK> condition in conditions) { Expression ruleExpression = condition.GetQueryExpression(context); predicate = Expression.Lambda <Func <T, bool> >(ruleExpression, new[] { expression }); } } return(predicate); }
/********* ** Public methods *********/ /// <summary>Update the patch data when the context changes.</summary> /// <param name="context">The condition context.</param> /// <returns>Returns whether the patch data changed.</returns> public virtual bool UpdateContext(ConditionContext context) { // update conditions bool conditionsChanged; { bool wasMatch = this.MatchesContext; this.MatchesContext = this.Conditions.Count == 0 || this.Conditions.Values.All(p => p.IsMatch(context)); conditionsChanged = wasMatch != this.MatchesContext; } // update asset name bool targetChanged = this.TokenableAssetName.UpdateContext(context); this.AssetName = this.NormaliseAssetName(this.TokenableAssetName.Value); return(conditionsChanged || targetChanged); }
/// <summary> /// Evaluates the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { var test = Test.GetValue(context); if (String.IsNullOrEmpty(test)) { return false; } if (!test.StartsWith(UrlRewriterManager.AppDomainAppPath) && !test.Contains(":")) { test = context.HttpContext.Server.MapPath(test); } var exists = File.Exists(test); return Pattern.InvertMatch ? !exists : exists; }
/// <summary> /// Evaluates the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { string test = Test.GetValue(context); if (String.IsNullOrEmpty(test)) return IsMatch(false); if (!test.StartsWith(HttpRuntime.AppDomainAppPath) && !test.Contains(":")) test = context.HttpContext.Server.MapPath(test); if (File.Exists(test)) { FileInfo file = new FileInfo(test); return IsMatch(file.Length > 0); } return IsMatch(false); }
public Expression <Func <T, bool> > GetFilterExpression <T>(IEnumerable <string> values) where T : SearchResultItem { bool comparison = false; bool.TryParse(values.FirstOrDefault(), out comparison); if ((!InnerItem.Apply_When_True && comparison) || (!InnerItem.Apply_When_False && !comparison)) { return(null); } ParameterExpression expression = Expression.Parameter(typeof(T), "item"); ConditionContext context = new ConditionContext(expression); var equals = new Func <Expression, Expression, Expression>(Expression.Equal); return(Expression.Lambda <Func <T, bool> >((Expression)equals(Expression.Property(context.ParameterExpression, typeof(T), SearchResultItemUtil.GetPropertyName <T>(InnerItem.Field_Name)), Expression.Constant(comparison)), new[] { expression })); }
/// <summary> /// Evaluates the specified context. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { var test = Test.GetValue(context); if (string.IsNullOrEmpty(test)) { return IsMatch(false); } if (!test.StartsWith(UrlRewriterManager.AppDomainAppPath) && !test.Contains(":")) { test = context.HttpContext.Server.MapPath(test); } if (File.Exists(test)) { var file = new FileInfo(test); return IsMatch(file.Length > 0); } return IsMatch(false); }
public PropertyConditionContext(ConditionContext parentContext, PropertyRule rule, string propertyName) { ParentContext = parentContext; Rule = rule; PropertyName = propertyName; }
/// <summary> /// Determines whether the specified log level is match. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { bool isMatch = false; string test = Test.GetValue(context); // pattern handles its own invert if needed isMatch = _pattern.IsMatch(test, context); Manager.LogIf(context.LogLevel >= 2, isMatch ? " Matched" : " Not Matched", context.LogCategory); return isMatch; }
/// <summary> /// Determines whether the specified log level is match. /// </summary> /// <param name="context">The context.</param> /// <returns> /// <see langword="true"/> if the specified log level is match; otherwise, <see langword="false"/>. /// </returns> public bool Evaluate(ConditionContext context) { var test = Test.GetValue(context); // pattern handles its own invert if needed var isMatch = _pattern.IsMatch(test, context); Logger.InfoFormat(isMatch ? " Matched" : " Not Matched"); return isMatch; }
/// <summary> /// Gets the value. /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public string GetValue(ConditionContext context) { return Pattern.Replace(_test, context); }
public ConditionContext condition() { ConditionContext _localctx = new ConditionContext(Context, State); EnterRule(_localctx, 12, RULE_condition); try { EnterOuterAlt(_localctx, 1); { State = 114; _localctx.c = condition_h(); State = 115; Match(Eof); _localctx.value = _localctx.c.value; } } catch (RecognitionException re) { _localctx.exception = re; ErrorHandler.ReportError(this, re); ErrorHandler.Recover(this, re); } finally { ExitRule(); } return _localctx; }
/// <summary> /// Tries the process. /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public bool TryExecute(RuleContext context) { // check if this rule should be run if (Action.IsMatch(context)) { Logger.Info("Rule Pattern Matched"); var skipOrNext = false; var conditionValues = new string[_conditions.Count]; // test to make sure all conditions are met for (var i = 0; i < _conditions.Count; i++) { var conditionContext = new ConditionContext(i, context, _conditions[i]); var containsOrNext = ConditionFlagsProcessor.HasOrNext(_conditions[i].Flags); var previousContainsOrNext = ConditionFlagsProcessor.HasOrNext(_conditions[Math.Max(0, i - 1)].Flags); if (skipOrNext && (previousContainsOrNext || containsOrNext)) { continue; } skipOrNext = false; // test the condition if it fails and then terminate if (!_conditions[i].Evaluate(conditionContext)) { if (containsOrNext) { continue; } return false; } else if (containsOrNext) { skipOrNext = true; } } // call an external method that might want to inherit from this rule implimentation OnExecuting(context); // process the substition for the pattern Action.Execute(context); // the pattern matched return true; } // the pattern did not match return false; }
/// <summary> /// Creates the condition execution context. /// </summary> /// <returns></returns> public ConditionContext CreateOutputConditionContext(Uri requestedUrl, byte[] responseContent) { // create properties var condition = new Mock<ICondition>().Object; // setup object var ruleContext = CreateOutputRuleContext(requestedUrl, responseContent); var conditionContext = new ConditionContext(0, ruleContext, condition); // return object return conditionContext; }
/// <summary> /// Creates the condition execution context. /// </summary> /// <returns></returns> public ConditionContext CreateConditionContext(Uri requestedUrl) { // create properties var condition = new Mock<ICondition>().Object; // setup object var ruleContext = CreateRuleContext(requestedUrl); var conditionContext = new ConditionContext(0, ruleContext, condition); // return object return conditionContext; }