public NotificationEventHandler(
[NotNull] INotificationRuleRepository notificationRuleRepository,
[NotNull] IRuleParser ruleParser,
[NotNull] IRuleExecutorDirector ruleExecutorDirector,
[NotNull] ILog log)
{
if (notificationRuleRepository == null)
{
throw new ArgumentNullException(nameof(notificationRuleRepository));
}
if (ruleParser == null)
{
throw new ArgumentNullException(nameof(ruleParser));
}
if (ruleExecutorDirector == null)
{
throw new ArgumentNullException(nameof(ruleExecutorDirector));
}
if (log == null)
{
throw new ArgumentNullException(nameof(log));
}
_notificationRuleRepository = notificationRuleRepository;
_ruleParser = ruleParser;
_ruleExecutorDirector = ruleExecutorDirector;
_log = log;
}
public void SetUp()
{
this.ruleRepo = MockRepository.GenerateStrictMock <IRuleRepo>();
this.emailService = MockRepository.GenerateStrictMock <IEmailService>();
this.ruleParser = MockRepository.GenerateStrictMock <IRuleParser>();
this.sender = new MailSender(this.ruleRepo, this.emailService, this.ruleParser);
}
public NotificationPollJob(
INotificationRuleRepository notificationRuleRepository,
IRuleParser ruleParser,
IRuleExecutorDirector ruleExecutorDirector)
{
_notificationRuleRepository = notificationRuleRepository;
_ruleParser = ruleParser;
_ruleExecutorDirector = ruleExecutorDirector;
}
/// <summary>
/// Feeds all tokens to the parser and returns the last result.
/// </summary>
private RuleResult FeedAll(IRuleParser parser, IEnumerable <Token> tokens)
{
RuleResult lastResult = default;
foreach (Token t in tokens)
{
lastResult = parser.FeedToken(t);
}
return(lastResult);
}
public void SetUp()
{
var ruleParsers = new List <IRuleParser>
{
new UglyFlatRuleParser(),
new CommentedFlatRuleParser(),
new StragetyRuleParser(),
new EasyTestStragetyRuleParser()
};
this.parser = ruleParsers[1];
}
public void TestDynamicRuleCreation()
{
IRuleParser parser = RuleParser.GetInstance();
string successAction;
string failAction;
IRule rule = parser.CreateRule(Files.SourceCode1, out successAction, out failAction);
Assert.IsNotNull(rule);
Assert.AreEqual("TEST ID 123", rule.Id);
Assert.AreEqual("PREDEFINE_ACTION_1", successAction);
Assert.AreEqual("PREDEFINE_ACTION_2", failAction);
}
/// <summary>
/// The host application must call this or no rewriting will take place
/// </summary>
/// <param name="log">Optional logger or null for logging to Trace output</param>
/// <param name="forwardTracePredicate">A function that determines which urls to
/// log traces for. If you have a specific URL that is not rewriting as you want then
/// add that url to this list to log an execution trace through the rewriting rules</param>
/// <param name="reverseTracePredicate">A list of the rewritten urls
/// to log traces for. If your site it redirecting to an unexpected
/// page and you want to know why it was redirected there, add the
/// rewritten/redirected url to this list</param>
/// <param name="factory">Pass a factory that can construct your
/// custom actions and custom conditions using Dependency Injection. You
/// can pass null if all of your custom extensions have a default public
/// constructor</param>
/// <param name="ruleStream">Pass the rewriting rules here. This allows you
/// to store your rules wherever you want (in a database for example).
/// You can also pass null to read rles from the RewriteRules.config
/// file just like the Microsoft one does</param>
/// <param name="ruleParser">Provide a custom parser to support your
/// own rule syntax, or pass null for backward compatibility with
/// the Microsoft IIS Rewriter module but with many more features</param>
public static void Initialize(
ILog log = null,
Func <string, bool> forwardTracePredicate = null,
Func <string, bool> reverseTracePredicate = null,
IFactory factory = null,
Stream ruleStream = null,
IRuleParser ruleParser = null)
{
if (_factory == null)
{
if (factory == null)
{
factory = new NinjectFactory();
}
_factory = factory;
}
if (_log == null)
{
if (log == null)
{
log = _factory.Create <ILog>();
}
_log = log;
}
if (ruleStream == null)
{
var filePath = HttpContext.Current.Server.MapPath("~/RewriteRules.config");
ruleStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
try
{
SetRules(LoadRules(ruleStream, null, ruleParser));
}
finally
{
ruleStream.Close();
}
DescribeRulesToTrace();
#if !TRACE_ALL
_forwardTracePredicate = forwardTracePredicate;
_reverseTracePredicate = reverseTracePredicate;
_tracingEnabled = forwardTracePredicate != null || reverseTracePredicate != null;
#endif
}
/// <summary>
/// Parses rules from a stream
/// </summary>
/// <param name="stream">The stream to read rules from</param>
/// <param name="encoding">The text encoding used in this stream, or null for UTF8</param>
/// <param name="ruleParser">A custom parser, or null to use the default parser</param>
/// <returns></returns>
public static IRuleList LoadRules(
Stream stream,
Encoding encoding = null,
IRuleParser ruleParser = null)
{
if (stream == null)
{
return(null);
}
encoding = encoding ?? Encoding.UTF8;
var parser = ruleParser ?? _factory.Create <StandardRuleParser>();
return(parser.Parse(stream, encoding));
}
public PolicyCheckEventHandler(
[NotNull] ITaskRepository taskRepository,
[NotNull] IPolicyRuleRepository policyRuleRepository,
[NotNull] IRuleExecutorDirector ruleExecutorDirector,
[NotNull] IEventProvider eventProvider,
[NotNull] IRuleParser ruleParser,
[NotNull] ILog logger,
[NotNull] ITelemetryScopeProvider telemetryScopeProvider)
{
if (taskRepository == null)
{
throw new ArgumentNullException(nameof(taskRepository));
}
if (policyRuleRepository == null)
{
throw new ArgumentNullException(nameof(policyRuleRepository));
}
if (ruleExecutorDirector == null)
{
throw new ArgumentNullException(nameof(ruleExecutorDirector));
}
if (eventProvider == null)
{
throw new ArgumentNullException(nameof(eventProvider));
}
if (ruleParser == null)
{
throw new ArgumentNullException(nameof(ruleParser));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (telemetryScopeProvider == null)
{
throw new ArgumentNullException(nameof(telemetryScopeProvider));
}
_taskRepository = taskRepository;
_policyRuleRepository = policyRuleRepository;
_ruleExecutorDirector = ruleExecutorDirector;
_eventProvider = eventProvider;
_ruleParser = ruleParser;
_logger = logger;
_telemetryScopeProvider = telemetryScopeProvider;
}
public void CombinedTests()
{
// Assemble
var ruleParsers = new List <IRuleParser>
{
new UglyFlatRuleParser(),
new CommentedFlatRuleParser(),
new StragetyRuleParser(),
new EasyTestStragetyRuleParser()
};
// Act
// Assert
ruleParsers.ForEach(
rp =>
{
this.parser = rp;
this.ParseRulesReturnsCorrectRules();
});
}
public RuleResult FeedToken(Token t)
{
if (_isFinished)
{
throw new Exception("Tried to feed a token to an already-finished ThenChainParser.");
}
var currentCallabck = _ruleSequence[_currentRuleIndex].onMatched;
// HACK: Create the first rule, if it hasn't been already.
if (_currentRule == null)
{
_currentRule = _ruleSequence[_currentRuleIndex].ruleFactory();
}
// Feed the token to the current rule
var result = _currentRule.FeedToken(t);
// If it failed, cascade that failure upwards
if (result.status == RuleStatus.Failed)
{
return(result);
}
// If it succeeded, invoke the callback and move to the next rule
if (result.status == RuleStatus.Complete)
{
currentCallabck(result.node);
_currentRuleIndex++;
// If the last rule just succeeded, the whole chain is complete.
if (_currentRuleIndex >= _ruleSequence.Count)
{
_isFinished = true;
return(RuleResult.Complete(_node));
}
_currentRule = _ruleSequence[_currentRuleIndex].ruleFactory();
}
return(RuleResult.GoodSoFar());
}
public WorkflowEventHandler(
[NotNull] IWorkflowRuleRepository workflowRuleRepository,
[NotNull] IRuleParser ruleParser,
[NotNull] IRuleExecutorDirector ruleExecutorDirector)
{
if (workflowRuleRepository == null)
{
throw new ArgumentNullException(nameof(workflowRuleRepository));
}
if (ruleParser == null)
{
throw new ArgumentNullException(nameof(ruleParser));
}
if (ruleExecutorDirector == null)
{
throw new ArgumentNullException(nameof(ruleExecutorDirector));
}
_workflowRuleRepository = workflowRuleRepository;
_ruleParser = ruleParser;
_ruleExecutorDirector = ruleExecutorDirector;
}
public RuleBuilder(string rules, IRuleParser parser)
{
_rules = rules;
_parser = parser;
}
/// <summary>
/// Initializes a new instance of the MailSender class.
/// </summary>
/// <param name="ruleRepo">Repository to handle persistence of MailRules.</param>
/// <param name="emailService">Service to send emails.</param>
/// <param name="ruleParser">Parser to determine which MailRules should be sent.</param>
public MailSender(IRuleRepo ruleRepo, IEmailService emailService, IRuleParser ruleParser)
{
this.ruleRepo = ruleRepo;
this.emailService = emailService;
this.ruleParser = ruleParser;
}
public void Reset()
{
_currentRuleIndex = 0;
_currentRule = _ruleSequence[0].ruleFactory();
_isFinished = false;
}
