public override SpecificationResult Evaluate(
IReadOnlyDictionary <string, object> values,
SpecificationEvaluationSettings settings)
{
List <string> details = new List <string>();
foreach (Specification s in this.Specifications)
{
var result = s.Evaluate(values, settings);
if (result.IsSatisfied)
{
return(SpecificationResult.True);
}
if (settings.IncludeDetails)
{
details.Add(result.Details);
}
}
return(SpecificationResult.Create(
false,
settings.IncludeDetails ? string.Format(SpecAbsRes.OrNotMatch, string.Join("|", details)) : null));
}
protected SpecificationResult Compare(
SpecificationValue left,
SpecificationValue rigth,
SpecificationEvaluationSettings settings)
{
if (left.ValueType != rigth.ValueType)
{
List <object> cast = new List <object>();
foreach (object leftValue in left.Values)
{
if (TypeHelper.HasMappingOrCast(leftValue, rigth.ValueType, settings.ValueSettings, out object leftCast))
{
cast.Add(leftCast);
}
else
{
if (settings.ThrowValueErrors)
{
throw new InvalidOperationException(
string.Format(
SpecAbsRes.KeyValueSpecificationTypeNotMatch,
left.ValueType,
this.Key,
this.Value.ValueType));
}
return(SpecificationResult.Create(
false,
settings.IncludeDetails
? string.Format(
SpecAbsRes.KeyValueSpecificationTypeNotMatch,
left.ValueType,
this.Key,
rigth.ValueType)
: null));
}
}
if (left.Values.Count == 1)
{
left = SpecificationValue.Single(cast.Single());
}
if (left.ValueMultiplicity == SpecificationValue.Multiplicity.AnyOf)
{
left = SpecificationValue.AnyOf(cast);
}
else if (left.ValueMultiplicity == SpecificationValue.Multiplicity.AllOf)
{
left = SpecificationValue.AllOf(cast);
}
else
{
throw new InvalidOperationException();
}
}
return(this.CompareSafeTypes(left, rigth, settings));
}
public override SpecificationResult Evaluate(
IReadOnlyDictionary <string, object> values,
SpecificationEvaluationSettings settings)
{
var result = this.Specification.Evaluate(values, settings);
if (!result.IsSatisfied)
{
return(SpecificationResult.True);
}
return(SpecificationResult.Create(
false,
settings.IncludeDetails ? string.Format(SpecAbsRes.NotNotMatch, this.Specification) : null));
}
public override SpecificationResult Evaluate(
IReadOnlyDictionary <string, object> values,
SpecificationEvaluationSettings settings)
{
int i = 0;
foreach (Specification s in this.Specifications)
{
var result = s.Evaluate(values, settings);
if (!result.IsSatisfied)
{
return(SpecificationResult.Create(
false,
settings.IncludeDetails ? string.Format(SpecAbsRes.AndNotMatch, i, result.Details) : null));
}
i++;
}
return(SpecificationResult.True);
}
protected override SpecificationResult CompareSafeTypes(
SpecificationValue left,
SpecificationValue right,
SpecificationEvaluationSettings settings)
{
bool result = this.ApplyMultiplicity(
left.ValueType == SpecificationValue.DataType.DateTime
? left.Values.Select(this.HandleDateTimeUtc)
: left.Values,
l => this.ApplyMultiplicity(
right.ValueType == SpecificationValue.DataType.DateTime
? right.Values.Select(this.HandleDateTimeUtc)
: right.Values,
r => this.CompareSingleValues(l, r),
right),
left);
return(SpecificationResult.Create(
result,
result ? null :
settings.IncludeDetails?string.Format(SpecAbsRes.CompareSpecificationNotMatch, right, left, this) : null));
}
public override SpecificationResult Evaluate(
IReadOnlyDictionary <string, object> values,
SpecificationEvaluationSettings settings)
{
if (values.ContainsKey(this.Key))
{
if (values[this.Key] != null)
{
return(SpecificationResult.True);
}
else
{
return(SpecificationResult.Create(
false,
settings.IncludeDetails ? string.Format(SpecAbsRes.HasValueNotMatchNull, this.Key) : null));
}
}
else
{
return(SpecificationResult.Create(
false,
settings.IncludeDetails ? string.Format(SpecAbsRes.HasValueNotMatch, this.Key) : null));
}
}
public override SpecificationResult Evaluate(
IReadOnlyDictionary <string, object> values,
SpecificationEvaluationSettings settings)
{
if (!values.ContainsKey(this.Key))
{
return(SpecificationResult.Create(
false,
settings.IncludeDetails
? string.Format(SpecAbsRes.KeyValueSpecificationMissingKey, this.Key)
: null));
}
object value = values[this.Key];
if (value == null)
{
return(SpecificationResult.Create(
false,
settings.IncludeDetails
? string.Format(SpecAbsRes.KeyValueSpecificationValueNull, this.Key)
: null));
}
SpecificationValue left;
string error;
if (!SpecificationValue.TryFrom(this.Key, values, settings.ValueSettings, out left, out error))
{
if (settings.ThrowValueErrors)
{
throw new InvalidOperationException(
string.Format(SpecAbsRes.KeyValueSpecificationUnableToResolveLeft, this, error));
}
return(SpecificationResult.False(
settings.IncludeDetails
? string.Format(SpecAbsRes.KeyValueSpecificationUnableToResolveLeft, this, error)
: null));
}
SpecificationValue right;
if (this.Value.IsReference)
{
string refKey = this.Value.Values.Single().ToString();
if (!SpecificationValue.TryFrom(refKey, values, settings.ValueSettings, out right, out error))
{
if (settings.ThrowValueErrors)
{
throw new InvalidOperationException(
string.Format(SpecAbsRes.KeyValueSpecificationUnableToResolveRight, this, error));
}
return(SpecificationResult.False(
settings.IncludeDetails
? string.Format(SpecAbsRes.KeyValueSpecificationUnableToResolveRight, this, error)
: null));
}
}
else
{
right = this.Value;
}
return(this.Compare(left, right, settings));
}
public override SpecificationResult Evaluate(
IReadOnlyDictionary <string, object> values,
SpecificationEvaluationSettings settings)
{
return(SpecificationResult.Create(this.Value, settings.IncludeDetails ? this.details : null));
}
