public void VerifyRule(IRuleRequest ruleRequest = null)
{
foreach (var action in RulesInContainer(ruleRequest))
{
action.VerifyRule(ruleRequest);
}
}
public override void VerifyRule(IRuleRequest request = null)
{
base.VerifyRule(request);
if (!StorageMechanism.Items.Any())
{
Logger("INFO", $"Cache empty for {RuleSetName}");
return;
}
if (AggregateRule == null)
{
Logger("ERROR", $"Aggregate rule for {RuleSetName} is empty");
return;
}
var filtered = AggregateFilter != null
? AggregateFilter.Compile().Invoke(StorageMechanism.Items, RuleRequest)
: StorageMechanism.Items;
var invalid = AggregateRule.Compile().Invoke(filtered);
if (!invalid)
{
return;
}
FailRule();
}
public virtual void VerifyRule(IRuleRequest request = null)
{
if (request == null)
{
request = Activator.CreateInstance <T>();
}
else
{
RecordRequest(request);
}
RuleRequest = (T)request;
}
public RuleContainer(IRuleRequest request)
{
var rules = new List <IRuleContainer>();
foreach (var _rule in request.Rules)
{
rules.Add(new RuleContainer(_rule));
}
Operand = request.Operand;
Negate = request.Negate;
Request = request;
Rules = rules;
}
protected IEnumerable <IRuleRunner> RulesInContainer(IRuleRequest ruleRequest)
{
if (ruleRequest == null)
{
return(null);
}
var found = Rules.Where(x => x.Key == ruleRequest.GetType());
var result = found
.Select(z => z.Value)
.Cast <IRuleRunner>();
return(result);
}
private static void EnsureCreated <T>(Action <T> setter = null) where T : IRuleRequest, new()
{
if (_rule == null)
{
_rule = Activator.CreateInstance <TRuleSetHandler>();
}
if (_request == null)
{
_request = Activator.CreateInstance <T>();
}
if (setter != null)
{
setter((T)_request);
}
}
protected void RecordRequest(IRuleRequest request)
{
Logger("DEBUG", "RecordRequest: " + request.Id);
if (!UpdateRuleCollectionOnSuccess)
{
return;
}
var item = (T)request;
var storage = StorageMechanism.Items.ToList();
if (!storage.Contains(item))
{
storage.Add(item);
}
_storageMechanism.Items = storage.AsQueryable();
}
public void Run(IRuleRequest item, bool addRequestToItemsCollection = true)
{
_ruleRequest = (T)item;
if (addRequestToItemsCollection)
{
StorageMechanism().Add((T)item);
_logger("INFO", "Added item to collection. Count = " + StorageMechanism().Count);
}
_logger("DEBUG", "Verify Maximum Count Rule");
VerifyMaximumCount();
_logger("DEBUG", "Verify Single Rule");
VerifySingleRule();
_logger("DEBUG", "Verify Aggregate Rule");
VerifyAggregateRule();
_logger("INFO", "Request passed rule : " + RuleType.Name);
}
public override void VerifyRule(IRuleRequest request = null)
{
base.VerifyRule(request);
if (StorageMechanism == null || !StorageMechanism.Items.Any())
{
return;
}
long count = StorageMechanism.Items.LongCount();
bool invalid = MaximumResultCount.HasValue && count >= MaximumResultCount;
if (!invalid)
{
return;
}
string log = string.Format("Maximum Count excedeed.. Maximum items allowed count : {0} total found: {1}",
MaximumResultCount, count);
FailRule(log);
}
public override void VerifyRule(IRuleRequest request = null)
{
base.VerifyRule(request);
if (!StorageMechanism.Items.Any())
{
return;
}
if (Rule != null)
{
var invalid = StorageMechanism.Items
.AsQueryable()
.Cast <T>()
.Where(Rule);
if (!invalid.Any())
{
return;
}
FailRule();
}
}