/// <summary>
/// Create/Update an And Rule for the rule results
/// </summary>
/// <param name="ruleResults"></param>
/// <param name="existingRule"></param>
/// <param name="negateResult"></param>
/// <returns></returns>
public static Rule AndRule(this List <RuleResult> ruleResults, Rule existingRule = null, bool negateResult = false)
{
if (ruleResults.Count < 2)
{
throw new ArgumentOutOfRangeException(nameof(ruleResults),
$"{nameof(ruleResults)} does not meet the requirements for the minimum number of members");
}
var refValues = ruleResults.Select(rr => (IEntity)(TypeKey)rr);
var refValueIds = new RuleCollect
{
RuleResultId = existingRule?.ReferenceValues.RuleResultId ?? GuidHelpers.NewTimeUuid(),
EntityIds = ImmutableList.CreateRange(refValues)
};
var lastChanged = ruleResults.OrderByDescending(rr => rr.LastChanged).First().LastChanged;
if (existingRule == null)
{
existingRule = new Rule
{
RuleId = GuidHelpers.NewTimeUuid()
};
}
existingRule.RuleName = $"Test all rule results are {!negateResult}";
existingRule.RuleType = RuleType.And;
existingRule.LastChanged = lastChanged;
existingRule.LastExecuted = lastChanged;
existingRule.NegateResult = negateResult;
existingRule.ReferenceValues = refValueIds;
return(existingRule);
}
/// <summary>
/// Create a RulePrescription (implicitly defining a RuleResult) from an ITypeKey.
/// This can be used as the Entities value within an IRuleProcessing derived object
/// </summary>
/// <param name="entity"></param>
/// <param name="existingRule"></param>
/// <returns></returns>
public static T RulePrescription <T>(this IEntity entity, Rule existingRule = null) where T : IRulePrescription, new()
{
var refValue = new T {
RuleResultId = existingRule?.ReferenceValues.RuleResultId ?? GuidHelpers.NewTimeUuid(), EntityIds = ImmutableList.Create(entity)
};
return(refValue);
}
/// <summary>
/// Create an OperandKey from an enumerable of Entity Ids
/// </summary>
/// <param name="sourceValueIds"></param>
/// <param name="entType"></param>
/// <param name="entityId"></param>
/// <returns></returns>
public static OperandKey OperandKey(this IEnumerable <Guid> sourceValueIds, EntityType entType, Guid?entityId = null)
{
if (!entityId.HasValue || entityId == Guid.Empty)
{
entityId = GuidHelpers.NewTimeUuid();
}
var opKey = new OperandKey {
EntType = entType, EntityId = entityId.Value, SourceEntityIds = ImmutableArray.CreateRange(sourceValueIds?.ToArray() ?? new Guid[0])
};
return(opKey);
}
/// <summary>
/// Create an OperandKey from a single Value
/// </summary>
/// <param name="value"></param>
/// <param name="entType"></param>
/// <param name="entityId"></param>
/// <returns></returns>
public static OperandKey OperandKey(this Value value, EntityType entType, Guid?entityId = null)
{
if (!entityId.HasValue || entityId == Guid.Empty)
{
entityId = GuidHelpers.NewTimeUuid();
}
var opKey = new OperandKey {
EntType = entType, EntityId = entityId.Value, SourceEntityIds = ImmutableArray.Create(value.EntityId)
};
return(opKey);
}
/// <summary>
/// Create a RulePrescription (implicitly defining a RuleResult) from a Processable Entity
/// This can be used as the Entities value within an IRuleProcessing derived object
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TU"></typeparam>
/// <param name="entity"></param>
/// <param name="existingRule"></param>
/// <returns></returns>
public static TU RulePrescription <T, TU>(this T entity, Rule existingRule = null) where T : IEntity where TU : IRulePrescription, new()
{
if (!entity.IsProcessable())
{
throw new ArgumentOutOfRangeException(nameof(entity), "RulePrescription helper creator is only for Processable entity types");
}
var entTypeKey = new TypeKey {
EntityId = entity.EntityId, EntType = entity.EntType, EntTags = entity.EntTags, LastChanged = entity.LastChanged
};
var refValue = new TU {
RuleResultId = existingRule?.ReferenceValues.RuleResultId ?? GuidHelpers.NewTimeUuid(), EntityIds = ImmutableList.Create((IEntity)entTypeKey)
};
return(refValue);
}
/// <summary>
/// Create a HasMeaningfulValue Rule for the value
/// </summary>
/// <param name="value"></param>
/// <param name="existingRule"></param>
/// <param name="negateResult"></param>
/// <returns></returns>
public static Rule HasMeaningfulValueRule(this Value value, Rule existingRule = null, bool negateResult = false)
{
if (existingRule == null)
{
existingRule = new Rule
{
RuleId = GuidHelpers.NewTimeUuid()
};
}
existingRule.RuleName = $"Test for meaningful value of Value {(TypeKey)value}";
existingRule.RuleType = RuleType.HasMeaningfulValue;
existingRule.LastChanged = value.LastChanged;
existingRule.LastExecuted = value.LastChanged;
existingRule.NegateResult = negateResult;
existingRule.ReferenceValues = value.RulePrescription <RuleUnary>(existingRule);
return(existingRule);
}
/// <summary>
/// Create an Exists Rule for the value
/// </summary>
/// <param name="entity"></param>
/// <param name="existingRule"></param>
/// <param name="negateResult"></param>
/// <returns></returns>
public static Rule ExistsRule(this IEntity entity, Rule existingRule = null, bool negateResult = true)
{
var nText = negateResult ? "non-" : "";
var ruleName = $"Test for {nText}existence of {entity.EntType.ToString()} {(TypeKey)entity}";
var refValues = (IRulePrescription)entity.RulePrescription <RuleUnary>();
if (existingRule == null)
{
existingRule = new Rule
{
RuleId = GuidHelpers.NewTimeUuid()
};
}
existingRule.RuleName = ruleName;
existingRule.RuleType = RuleType.Exists;
existingRule.LastChanged = entity.LastChanged;
existingRule.LastExecuted = entity.LastChanged;
existingRule.NegateResult = negateResult;
existingRule.ReferenceValues = refValues;
return(existingRule);
}