public void GetSequence_Should_Return_Formatted_Sequence() { var rules = new Dictionary <string, string>(); rules.Add("3", "C"); rules.Add("5", "E"); rules.Add("3,5", "Z"); _ruleProvider.GetRules().Returns(rules); var result = _multipleSequence.GetSequence(15); Assert.AreEqual(result.Count, 16); Assert.AreEqual(result[1], 1); Assert.AreEqual(result[3], "C"); Assert.AreEqual(result[5], "E"); Assert.AreEqual(result[15], "Z"); }
public IEnumerable <IEnumerable <string> > GetPossibleSorts(string[] names) { var permutations = PermutationService.GenerateFor(names); var rules = _ruleProvider.GetRules(); return(permutations.Where(p => rules.All(r => r.Matches(p)))); }
public IEnumerable <Rule> GetRules() { var filter = _description; IRuleProvider inner = _inner as IRuleProvider; if (inner != null) { foreach (var rule in inner.GetRules()) { rule.Filter = filter; yield return(rule); } } }
private void PopulateSequenceForMultiples(int value) { var rules = _ruleProvider.GetRules(); var ruleAssert = new List <MultipleRuleModel>(); var isRulePassed = false; foreach (var rule in rules) { var multiples = rule.Key.Split(','); foreach (var item in multiples) { int multipleRuleNumber; if (int.TryParse(item, out multipleRuleNumber)) { if (!value.IsMultipleOf(multipleRuleNumber)) { isRulePassed = false; break; } else { isRulePassed = true; } } else { throw new InvalidOperationException(); } } ruleAssert.Add(new MultipleRuleModel { IsRulePassed = isRulePassed, Rule = rule.Key, Priority = multiples.Length }); } var passedRule = ruleAssert.Where(x => x.IsRulePassed).OrderByDescending(x => x.Priority).FirstOrDefault(); if (passedRule != null) { _sequence.Add(rules[passedRule.Rule]); } else { _sequence.Add(value); } }
public bool CheckRules(IEnumerable <Person> persons, IEnumerable <WorkShift> workShifts, ApplyStage stage) { var finalResult = true; var rules = ruleProvider.GetRules().Where(x => x.ApplyStages.HasFlag(stage)); Logger.LogInformation($"Checking {stage} stage rules with stage ..."); foreach (var rule in rules) { var result = rule.CheckRule(persons, workShifts); Logger.LogInformation($"Checking rule {rule.GetType()}: {result}"); finalResult &= result; if (!finalResult) { break; } } return(finalResult); }
internal static void DumpRule(IRuleProvider root, TextWriter output) { foreach (var rule in root.GetRules()) { var attr = rule.SourceAttribute; output.Write($"[{attr.Name}] -->"); if (rule.Filter != null) { output.Write($"[filter: {rule.Filter}]-->"); } if (rule.Converters != null) { foreach (var converterType in rule.Converters) { output.Write($"{ConverterManager.ExactMatch.TypeToString(converterType)}-->"); } } output.Write(rule.UserType.GetDisplayName()); output.WriteLine(); } }
/// <summary> /// Gets all static rules defined on the specified types. /// </summary> /// <param name="types"></param> /// <returns></returns> public static IEnumerable <Rule> GetRules(IEnumerable <Type> types) { // Fetch the set of rules declared on the specified types List <Rule> rules = new List <Rule>(); foreach (Type type in types .Where(type => type.IsClass) .SelectMany(type => type.BaseType.IsGenericType ? new Type[] { type, type.BaseType } : new Type[] { type })) { rules.AddRange( type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) .Where(field => typeof(IRuleProvider).IsAssignableFrom(field.FieldType)) .SelectMany(field => { IRuleProvider ruleProvider = (IRuleProvider)field.GetValue(null); if (ruleProvider != null) { return(ruleProvider.GetRules(type, field.Name)); } else { StackTrace stackTrace = new StackTrace(); List <MethodBase> callStackMethods = stackTrace.GetFrames() .Select(f => f.GetMethod()) .ToList(); Type currentType = callStackMethods.First().DeclaringType; callStackMethods.Reverse(); MethodBase ruleProviderCall = callStackMethods.FirstOrDefault(method => currentType != method.DeclaringType && typeof(IRuleProvider).IsAssignableFrom(method.DeclaringType)); if (ruleProviderCall != null) { string errorMessage = string.Format( "'{0}'.'{1}' is null, declared as a '{2}', and '{3}'.'{4}' is creating/accessing rules. As such, it appears that the '{2}' is still initializing and rules will not register properly. Please see the call stack.", type.Name, field.Name, typeof(IRuleProvider).Name, ruleProviderCall.DeclaringType.Name, ruleProviderCall.Name ); throw new ApplicationException(errorMessage); } } return(new Rule[] { }); }) .Where(rule => rule != null) ); // Ensure the error code has been set on all statically declared condition types foreach (ConditionType error in type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic) .Where(field => typeof(ConditionType).IsAssignableFrom(field.FieldType)) .Select(field => { ConditionType error = (ConditionType)field.GetValue(null); if (error != null && error.Code == null) { error.Code = field.DeclaringType.Name + "." + field.Name; } return(error); })) { } } return(rules); }
private void InitializeProviders(DateTime from, DateTime to) { bookings = bookingProvider.GetBookings(from, to); rules = ruleProvider.GetRules(); times = timeProvider.GetTimes(); }