public void Initialize() { _request1 = new MockRequestInfo("/path1/path2?param=value", "http", "test.com", 80); _request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443); _request3 = new MockRequestInfo("/path1/path2/", "http", "test.com", 80); _request1.NewPath[1] = "changed1"; _request1.NewParameters["param"] = new List <string> { "changed" }; _request1.PathChanged(); _request1.SetServerVariable("PATH_INFO", "/company/news/"); _request1.SetHeader("HOST", "www.mysite.com"); _request2.NewPath[2] = "changed2"; _request2.PathChanged(); _request2.SetServerVariable("SERVER_PORT", "443"); _request2.SetHeader("USER_AGENT", "blah blah blah"); _request3.NewUrlString = "/changed1/changed2/"; _request3.NewParameters["param"] = new List <string> { "added" }; _request3.ParametersChanged(); IFactory factory = new NinjectFactory(); _valueGetter = factory.Create <IValueGetter>(); _ruleResult = factory.Create <IRuleResult>(); }
public override void PerformAction( IRuleExecutionContext requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { stopProcessing = _stopProcessing; endRequest = _endRequest; if (_actions != null && _actions.Count > 0) { foreach (var action in _actions) { bool actionStopProcessing; bool actionEndRequest; action.PerformAction(requestInfo, ruleResult, out actionStopProcessing, out actionEndRequest); if (actionEndRequest) { endRequest = true; } if (actionStopProcessing) { stopProcessing = true; break; } } } }
public static void AssignRuleName(this IRuleResult ruleResult, string ruleName) { if (ruleResult != null) { ruleResult.Name = ruleResult.Name ?? ruleName; } }
private void AddToAsyncRuleResults(IRuleResult ruleResult) { if (ruleResult != null) { _asyncRuleResults.Add(ruleResult); } }
/// <summary> /// Add a violation to the queue. /// </summary> /// <param name="result"> /// IRuleResult derived class to add. /// </param> public void AddAViolation(IRuleResult result) { if (result.Severity > 0) { this._violations.Enqueue(result); } }
public int GetInt(IRequestInfo requestInfo, IRuleResult ruleResult, int defaultValue) { var value = GetString(requestInfo, ruleResult); int intValue; return(int.TryParse(value, out intValue) ? intValue : defaultValue); }
public static WrappedResponse <T> WrappedResponse <T>(this IRuleResult rulesResult) { return(new WrappedResponse <T> { ResultType = ResultType.BadRequest, State = ((RuleWithStateResult)rulesResult).State }); }
private void AddToRuleResults(IRuleResult ruleResult, string ruleName) { ruleResult.AssignRuleName(ruleName); if (ruleResult != null) { _ruleResults.Add(ruleResult); } }
public override void PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { stopProcessing = _stopProcessing; endRequest = _endRequest; }
public override void PerformAction( IRuleExecutionContext requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { stopProcessing = true; endRequest = true; }
public string GetString(IRequestInfo requestInfo, IRuleResult ruleResult) { var value = _getValueFunc(requestInfo, ruleResult); if (_operation != null) { value = _operation.Execute(value); } return(value); }
public override void PerformAction( IRuleExecutionContext requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { switch (_scope) { case Scope.Header: foreach (var header in requestInfo.GetHeaderNames()) { if (!_scopeIndex.Contains(header.ToLower())) { requestInfo.SetHeader(header, null); } } break; case Scope.Parameter: var parameters = new DefaultDictionary <string, IList <string> >(StringComparer.OrdinalIgnoreCase); foreach (var parameterName in _scopeIndex) { IList <string> parameterValue; if (requestInfo.NewParameters.TryGetValue(parameterName, out parameterValue)) { if (parameterValue != null && parameterValue.Count > 0) { parameters[parameterName] = parameterValue; } } } requestInfo.NewParameters = parameters; break; case Scope.PathElement: // Note that _scopeIndexValue is sorted into ascending order and always includes 0 var newPath = _scopeIndexValue .Where(i => i >= 0 && i < requestInfo.NewPath.Count) .Select(index => requestInfo.NewPath[index]) .ToList(); if (newPath.Count < 2) { newPath.Add(string.Empty); } requestInfo.NewPath = newPath; break; case Scope.HostElement: // TODO: but only if this makes any sense break; } stopProcessing = _stopProcessing; endRequest = _endRequest; }
public void Initialize() { _request1 = new MockRequestInfo("/path1/path2/path3?param=value"); _request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443); _request3 = new MockRequestInfo("/path1/path2/"); _request4 = new MockRequestInfo("/"); IFactory factory = new NinjectFactory(); _deleteAction = factory.Create<IDeleteAction>(); _ruleResult = factory.Create<IRuleResult>(); }
void IAction.PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { var result = Evaluate(requestInfo); stopProcessing = result.StopProcessing; endRequest = result.EndRequest; }
public void Initialize() { _request1 = new MockRequestInfo("/path1/path2/path3?p2=v2"); _request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443); _request3 = new MockRequestInfo("/path1/path2/?p1=v1&p2=v2&p3=v3"); _request4 = new MockRequestInfo("/?p3=v3&p2=v2"); IFactory factory = new NinjectFactory(); _keepAction = factory.Create<IKeepAction>(); _ruleResult = factory.Create<IRuleResult>(); }
private async Task ExecuteParallelRules(IEnumerable <IRuleAsync <T> > rules) { foreach (var rule in GetParallelRules(rules)) { await InvokeNestedRulesAsync(rule.Configuration.InvokeNestedRulesFirst, rule); if (rule.CanInvoke() && !_ruleEngineConfiguration.IsRuleEngineTerminated()) { await InvokeProactiveRulesAsync(rule); _parallelRuleResults.Add(await Task.Factory.StartNew(async() => { IRuleResult ruleResult = null; try { ruleResult = await ExecuteRuleAsync(rule); } catch (Exception exception) { rule.UnhandledException = exception; if (_rxRuleService.GetExceptionRules().ContainsKey(rule.GetType())) { await InvokeExceptionRulesAsync(rule); } else { var globalExceptionHandler = _rules.GetGlobalExceptionHandler(); if (globalExceptionHandler is IRuleAsync <T> ruleAsync) { globalExceptionHandler.UnhandledException = exception; await ExecuteAsyncRules(new List <IRuleAsync <T> > { ruleAsync }); } else { throw; } } } return(ruleResult); }, rule.ParallelConfiguration.CancellationTokenSource?.Token ?? CancellationToken.None, rule.ParallelConfiguration.TaskCreationOptions, rule.ParallelConfiguration.TaskScheduler)); await InvokeReactiveRulesAsync(rule); } await InvokeNestedRulesAsync(!rule.Configuration.InvokeNestedRulesFirst, rule); } }
public void Initialize() { _request1 = new MockRequestInfo("/path1/path2/path3?param=value"); _request2 = new MockRequestInfo("/path1/path2", "https", "secure.test.com", 443); _request3 = new MockRequestInfo("/path1/path2/"); _request4 = new MockRequestInfo("/"); IFactory factory = new NinjectFactory(); _replaceAction = factory.Create <IReplaceAction>(); _valueGetter = factory.Create <IValueGetter>().Initialize(Scope.Literal, "NewValue"); _ruleResult = factory.Create <IRuleResult>(); }
public override void PerformAction( IRuleExecutionContext requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { var value = _valueGetter.GetString(requestInfo, ruleResult); _action(requestInfo, value); stopProcessing = _stopProcessing; endRequest = _endRequest; }
public async Task given_rates_data_converrt_currency_to_USD() { var dataLocator = new MockExchangeRateAPI(); var repository = new ExchangeRateCurrencyRepository(dataLocator); var context = new CurrencyContext(100.00) { CurrencyTo = "EUR", CurrencyFrom = "USD" }; var engine = new ExchangeCurrencyRulesEngine(context, repository); IRuleResult <double> result = await engine.Execute(); }
public override void PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { if (requestInfo.NewPath != null && requestInfo.NewPath.Count > _maximumDepth) { requestInfo.NewPath = requestInfo.NewPath.Take(_maximumDepth).ToList(); } stopProcessing = _stopProcessing; endRequest = _endRequest; }
public override void PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { foreach (var action in _actions) { action(requestInfo); } stopProcessing = _stopProcessing; endRequest = _endRequest; }
public override void PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { if (requestInfo.ExecutionMode != ExecutionMode.TraceOnly) { var url = requestInfo.NewUrlString; requestInfo.DeferredActions.Add(ri => _redirectAction(ri, url)); } stopProcessing = _stopProcessing; endRequest = _endRequest; }
public override void PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { if (requestInfo.ExecutionMode != ExecutionMode.TraceOnly) { requestInfo.Context.Response.StatusDescription = _statusLine; requestInfo.Context.Response.Write(_responseLine); } stopProcessing = _stopProcessing; endRequest = _endRequest; }
private void SetSerializedResults(IRuleResultList transfferedResults, IRuleResult overrideResult) { if (transfferedResults.Any()) { if (overrideResult == null) { Results = transfferedResults; Results.SetKeysToNegative(); TransferredResults = true; } else { OverrideResult = overrideResult; } } }
public void Initialize() { _request1 = new MockRequestInfo(""); _request2 = new MockRequestInfo("/"); _request3 = new MockRequestInfo("/path1"); _request4 = new MockRequestInfo("path1/"); _request5 = new MockRequestInfo("path1"); _request6 = new MockRequestInfo("/path1/path2"); _request7 = new MockRequestInfo("path1/path2/"); _request8 = new MockRequestInfo("path1/path2"); IFactory factory = new NinjectFactory(); _normalizeAction = factory.Create <INormalizeAction>(); _ruleResult = factory.Create <IRuleResult>(); }
public bool Test(IRuleExecutionContext request, IRuleResult ruleResult) { if (_trackAllCaptures) { ruleResult.Properties.Set(true, "trackAllCaptures"); } var result = _testFunc(request, ruleResult); if (_trackAllCaptures) { ruleResult.Properties.Set(false, "trackAllCaptures"); } return(result); }
public override void PerformAction( IRequestInfo requestInfo, IRuleResult ruleResult, out bool stopProcessing, out bool endRequest) { stopProcessing = _stopProcessing; endRequest = _endRequest; if (_actions != null && _actions.Count > 0) { if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly) { requestInfo.Log.TraceActionListBegin(requestInfo, this); } foreach (var action in _actions) { bool actionStopProcessing; bool actionEndRequest; action.PerformAction(requestInfo, ruleResult, out actionStopProcessing, out actionEndRequest); if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly) { requestInfo.Log.TraceAction(requestInfo, action, actionEndRequest, actionStopProcessing); } if (actionEndRequest) { endRequest = true; } if (actionStopProcessing) { stopProcessing = true; break; } } if (requestInfo.ExecutionMode != ExecutionMode.ExecuteOnly) { requestInfo.Log.TraceActionListEnd(requestInfo, stopProcessing); } } }
public bool Test(IRequestInfo request, IRuleResult ruleResult) { var path = _valueGetter.GetString(request, ruleResult); try { if (!Path.IsPathRooted(path)) { path = request.Application.Server.MapPath(path); } return(_inverted ? !_testFunc(path) : _testFunc(path)); } catch { // When there is a permissions issue we can't tell if it exists or not return(false); } }
private void Evaluate(List <RulesChain> rulesToBeEvaluated, bool isAlternativeChain = false) { foreach (RulesChain currentRuleChain in rulesToBeEvaluated) { IRuleResult currentRulesChainResult = currentRuleChain.Rule.Eval(); if (currentRulesChainResult.IsSuccess) { currentRulesChainResult.Execute(); if (isAlternativeChain) { break; } } else { this.Evaluate(currentRuleChain.ElseRules, true); } } }
private bool Any(IRuleExecutionContext request, IRuleResult ruleResult, bool expected) { if (_conditions == null || _conditions.Count == 0) { return(false); } foreach (var condition in _conditions) { var isTrue = condition.Test(request, ruleResult); if (isTrue == expected) { return(true); } } return(false); }