protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value != null)
{
if (value.ToString().Equals(ValueToCompare.ToString()))
{
return(new ValidationResult(
FormatErrorMessage(validationContext.DisplayName), new[] { validationContext.MemberName }));
}
}
return(ValidationResult.Success);
}
public virtual void Compare(object entity, Action <string> onFail)
{
var entityValue = Property.GetValue(entity, null);
if (ExternalLibraryBoundary.IsThisAnEntityObject(ValueToCompare))
{
if (ExternalLibraryBoundary.AreTheseTheSameEntity(ValueToCompare, entityValue))
{
onFail(String.Format("References for property {0} do not match.\n Expected ID {1}\n got {2}",
Property.Name,
ExternalLibraryBoundary.GetValueOfId(ValueToCompare),
ExternalLibraryBoundary.GetValueOfId(entityValue)));
}
}
else if (!ValueToCompare.Equals(entityValue))
{
onFail(String.Format("Values for property {0} did not match. {1} != {2}", Property.Name,
ValueToCompare, entityValue));
}
}
/// <summary>
/// Determine if the input values matches, depending on the input operator and options.
/// </summary>
/// <param name="provider">An IFormatProvider interface implementation that supplies culture-specific formatting information.</param>
/// <returns>true if the values matches; false otherwise.</returns>
public virtual bool Matches(IFormatProvider provider)
{
bool ret = false;
string v;
string vtc;
UniversalConverterInput clone;
switch (Operator)
{
case UniversalConverterOperator.Equal:
if (Value == null)
{
if (ValueToCompare == null)
{
ret = true;
break;
}
// use string comparison (to compare "" to null or similar)
v = ValueToCompareToString(provider, false);
ret = v == null;
break; // false
}
if (Value.Equals(ValueToCompare))
{
ret = true;
break;
}
v = Value as string;
if (v != null)
{
vtc = ValueToCompareToString(provider, true);
ret = string.Compare(v, vtc, StringComparison) == 0;
break;
}
if ((Options & UniversalConverterOptions.Convert) == UniversalConverterOptions.Convert)
{
object cvalue;
if (ConversionService.TryChangeType(ValueToCompare, Value.GetType(), provider, out cvalue))
{
if (Value.Equals(cvalue))
{
ret = true;
break;
}
if (Value.GetType() == typeof(string))
{
string sv = (string)cvalue;
if ((Options & UniversalConverterOptions.Trim) == UniversalConverterOptions.Trim)
{
sv = sv.Trim();
}
if ((Options & UniversalConverterOptions.Nullify) == UniversalConverterOptions.Nullify)
{
if (sv.Length == 0)
{
sv = null;
}
}
if (Value.Equals(sv))
{
ret = true;
break;
}
}
}
}
break;
case UniversalConverterOperator.NotEqual:
clone = Clone();
clone.Operator = UniversalConverterOperator.Equal;
ret = clone.Matches(provider);
break;
case UniversalConverterOperator.Contains:
v = ValueToString(provider);
if (v == null)
{
break;
}
vtc = ValueToCompareToString(provider, true);
if (vtc == null)
{
break;
}
ret = v.IndexOf(vtc, StringComparison) >= 0;
break;
case UniversalConverterOperator.StartsWith:
v = ValueToString(provider);
if (v == null)
{
break;
}
vtc = ValueToCompareToString(provider, true);
if (vtc == null)
{
break;
}
ret = v.StartsWith(vtc, StringComparison);
break;
case UniversalConverterOperator.EndsWith:
v = ValueToString(provider);
if (v == null)
{
break;
}
vtc = ValueToCompareToString(provider, true);
if (vtc == null)
{
break;
}
ret = v.EndsWith(vtc, StringComparison);
break;
case UniversalConverterOperator.LesserThanOrEqual:
case UniversalConverterOperator.LesserThan:
case UniversalConverterOperator.GreaterThanOrEqual:
case UniversalConverterOperator.GreaterThan:
var cv = Value as IComparable;
if (cv == null || ValueToCompare == null)
{
break;
}
IComparable cvtc;
if (!Value.GetType().IsAssignableFrom(ValueToCompare.GetType()))
{
cvtc = ConversionService.ChangeType(ValueToCompare, Value.GetType(), provider) as IComparable;
}
else
{
cvtc = ValueToCompare as IComparable;
}
if (cvtc == null)
{
break;
}
int comparison;
v = Value as string;
if (StringComparison != StringComparison.CurrentCulture) // not the default? use the special string comparer
{
vtc = ValueToCompareToString(provider, true);
comparison = string.Compare(v, vtc, StringComparison);
}
else
{
comparison = cv.CompareTo(cvtc);
}
if (comparison == 0)
{
ret = Operator == UniversalConverterOperator.GreaterThanOrEqual || Operator == UniversalConverterOperator.LesserThanOrEqual;
break;
}
if (comparison < 0)
{
ret = Operator == UniversalConverterOperator.LesserThan || Operator == UniversalConverterOperator.LesserThanOrEqual;
break;
}
ret = Operator == UniversalConverterOperator.GreaterThan || Operator == UniversalConverterOperator.GreaterThanOrEqual;
break;
case UniversalConverterOperator.Between:
clone = Clone();
clone.ValueToCompare = MinimumValue;
clone.Operator = UniversalConverterOperator.GreaterThanOrEqual;
if (!clone.Matches(provider))
{
break;
}
clone = Clone();
clone.ValueToCompare = MaximumValue;
clone.Operator = UniversalConverterOperator.LesserThan;
ret = clone.Matches(provider);
break;
case UniversalConverterOperator.IsType:
case UniversalConverterOperator.IsOfType:
Type tvtc = ValueToCompareToType(provider);
if (tvtc == null)
{
break;
}
if (Value == null)
{
if (tvtc.IsValueType)
{
break;
}
ret = (Options & UniversalConverterOptions.NullMatchesType) == UniversalConverterOptions.NullMatchesType;
break;
}
if (Operator == UniversalConverterOperator.IsType)
{
ret = Value.GetType() == tvtc;
}
else
{
ret = tvtc.IsAssignableFrom(Value.GetType());
}
break;
}
return(Reverse ? !ret : ret);
}
