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();
}
