private static Expression Evaluate(this SCIMComparisonExpression comparisonExpression, ParameterExpression parameterExpression)
{
var originalParameterExpression = parameterExpression;
if (parameterExpression.Type == typeof(SCIMRepresentationModel))
{
var commonAttribute = GetCommonAttribute(comparisonExpression.LeftExpression, parameterExpression);
if (commonAttribute != null)
{
return(BuildComparison(comparisonExpression, commonAttribute));
}
parameterExpression = Expression.Parameter(typeof(SCIMRepresentationAttributeModel), "ra");
}
var result = comparisonExpression.LeftExpression.Evaluate(parameterExpression, (param) => BuildAttributeComparison(comparisonExpression, param));
if (originalParameterExpression.Type == typeof(SCIMRepresentationModel))
{
var attributesProperty = Expression.Property(originalParameterExpression, "Attributes");
var anyLambda = Expression.Lambda <Func <SCIMRepresentationAttributeModel, bool> >(result, parameterExpression);
return(Expression.Call(typeof(Enumerable), "Any", new[] { typeof(SCIMRepresentationAttributeModel) }, attributesProperty, anyLambda));
}
return(result);
}
private static Expression BuildAttributeComparison(SCIMComparisonExpression comparisonExpression, Expression representationAttrExpr)
{
var propertySchemaAttribute = Expression.Property(representationAttrExpr, "SchemaAttribute");
var propertySchemaType = Expression.Property(propertySchemaAttribute, "Type");
var propertyValues = Expression.Property(representationAttrExpr, "Values");
var attrValue = Expression.Parameter(typeof(SCIMRepresentationAttributeValueModel), "prop");
var propertyValueString = Expression.Property(attrValue, "ValueString");
var propertyValueInteger = Expression.Property(attrValue, "ValueInteger");
var propertyValueDatetime = Expression.Property(attrValue, "ValueDateTime");
var propertyValueBoolean = Expression.Property(attrValue, "ValueBoolean");
var attrInteger = Expression.Parameter(typeof(int), "prop");
var attrDateTime = Expression.Parameter(typeof(DateTime), "prop");
var attrString = Expression.Parameter(typeof(string), "prop");
var attrBoolean = Expression.Parameter(typeof(bool), "prop");
Expression anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Constant(false), attrValue),
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Constant(false), attrValue),
anyStringLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Constant(false), attrValue),
anyBooleanLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Constant(false), attrValue);
switch (comparisonExpression.ComparisonOperator)
{
case SCIMComparisonOperators.NE:
anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(NotEqual(propertyValueInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrValue);
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(NotEqual(propertyValueDatetime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrValue);
anyStringLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(NotEqual(propertyValueString, Expression.Constant(comparisonExpression.Value)), attrValue);
anyBooleanLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(NotEqual(propertyValueBoolean, Expression.Constant(ParseBoolean(comparisonExpression.Value))), attrValue);
break;
case SCIMComparisonOperators.GT:
anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(GreaterThan(propertyValueInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrValue);
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(GreaterThan(propertyValueDatetime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrValue);
break;
case SCIMComparisonOperators.GE:
anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(GreaterThanOrEqual(propertyValueInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrValue);
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(GreaterThanOrEqual(propertyValueDatetime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrValue);
break;
case SCIMComparisonOperators.LE:
anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(LessThanOrEqual(propertyValueInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrValue);
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(LessThanOrEqual(propertyValueDatetime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrValue);
break;
case SCIMComparisonOperators.LT:
anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(LessThan(propertyValueInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrValue);
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(LessThan(propertyValueDatetime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrValue);
break;
case SCIMComparisonOperators.EQ:
anyIntegerLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Equal(propertyValueInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrValue);
anyDateTimeLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Equal(propertyValueDatetime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrValue);
anyStringLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Equal(propertyValueString, Expression.Constant(comparisonExpression.Value)), attrValue);
anyBooleanLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Equal(propertyValueBoolean, Expression.Constant(ParseBoolean(comparisonExpression.Value))), attrValue);
break;
case SCIMComparisonOperators.SW:
var startWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
anyStringLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Call(propertyValueString, startWith, Expression.Constant(comparisonExpression.Value)), attrValue);
break;
case SCIMComparisonOperators.EW:
var endWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
anyStringLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Call(propertyValueString, endWith, Expression.Constant(comparisonExpression.Value)), attrValue);
break;
case SCIMComparisonOperators.CO:
var contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
anyStringLambda = Expression.Lambda <Func <SCIMRepresentationAttributeValueModel, bool> >(Expression.Call(propertyValueString, contains, Expression.Constant(comparisonExpression.Value)), attrValue);
break;
}
var anyMethodType = typeof(Enumerable).GetMethods().First(m => m.Name == "Any" && m.GetParameters().Length == 2).MakeGenericMethod(typeof(SCIMRepresentationAttributeValueModel));
var anyInteger = Expression.Call(anyMethodType, propertyValues, anyIntegerLambda);
var anyDateTime = Expression.Call(anyMethodType, propertyValues, anyDateTimeLambda);
var anyString = Expression.Call(anyMethodType, propertyValues, anyStringLambda);
var anyBoolean = Expression.Call(anyMethodType, propertyValues, anyBooleanLambda);
var equalValue = Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.INTEGER)), anyInteger),
Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.DATETIME)), anyDateTime),
Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.STRING)), anyString),
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.BOOLEAN)), anyBoolean)
)
)
);
return(equalValue);
}
private static Expression BuildComparison(SCIMComparisonExpression comparisonExpression, MemberExpression representationExpr)
{
switch (comparisonExpression.ComparisonOperator)
{
case SCIMComparisonOperators.NE:
if (representationExpr.Type == typeof(DateTime))
{
return(NotEqual(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(NotEqual(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(bool))
{
return(NotEqual(representationExpr, Expression.Constant(ParseBoolean(comparisonExpression.Value))));
}
return(NotEqual(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.GT:
if (representationExpr.Type == typeof(DateTime))
{
return(GreaterThan(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(GreaterThan(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
return(GreaterThan(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.GE:
if (representationExpr.Type == typeof(DateTime))
{
return(GreaterThanOrEqual(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(GreaterThanOrEqual(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
return(GreaterThanOrEqual(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.LE:
if (representationExpr.Type == typeof(DateTime))
{
return(LessThanOrEqual(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(LessThanOrEqual(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
return(LessThanOrEqual(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.LT:
if (representationExpr.Type == typeof(DateTime))
{
return(LessThan(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(LessThan(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
return(LessThan(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.EQ:
if (representationExpr.Type == typeof(DateTime))
{
return(Equal(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Equal(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(bool))
{
return(Equal(representationExpr, Expression.Constant(ParseBoolean(comparisonExpression.Value))));
}
return(Expression.Equal(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.SW:
var startWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
return(Expression.Call(representationExpr, startWith, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.EW:
var endWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
return(Expression.Call(representationExpr, endWith, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.CO:
var contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
return(Expression.Call(representationExpr, contains, Expression.Constant(comparisonExpression.Value)));
}
return(null);
}
private static Expression BuildAttributeComparison(SCIMComparisonExpression comparisonExpression, Expression representationAttrExpr)
{
var propertySchemaAttribute = Expression.Property(representationAttrExpr, "SchemaAttribute");
var propertySchemaType = Expression.Property(propertySchemaAttribute, "Type");
var propertyValuesString = Expression.Property(representationAttrExpr, "ValuesString");
var propertyValuesBoolean = Expression.Property(representationAttrExpr, "ValuesBoolean");
var propertyValuesInt = Expression.Property(representationAttrExpr, "ValuesInteger");
var propertyValuesDateTime = Expression.Property(representationAttrExpr, "ValuesDateTime");
var propertyValuesDecimal = Expression.Property(representationAttrExpr, "ValuesDecimal");
var propertyValuesBinary = Expression.Property(representationAttrExpr, "ValuesByte");
var attrInteger = Expression.Parameter(typeof(int), "prop");
var attrDateTime = Expression.Parameter(typeof(DateTime), "prop");
var attrString = Expression.Parameter(typeof(string), "prop");
var attrBoolean = Expression.Parameter(typeof(bool), "prop");
var attrDecimal = Expression.Parameter(typeof(decimal), "prop");
var attrBinary = Expression.Parameter(typeof(byte[]), "prop");
Expression anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.Constant(false), attrInteger),
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.Constant(false), attrDateTime),
anyStringLambda = Expression.Lambda <Func <string, bool> >(Expression.Constant(false), attrString),
anyBooleanLambda = Expression.Lambda <Func <bool, bool> >(Expression.Constant(false), attrBoolean),
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.Constant(false), attrDecimal),
anyBinaryLambda = Expression.Lambda <Func <byte[], bool> >(Expression.Constant(false), attrBinary);
Expression equalValue = null;
switch (comparisonExpression.ComparisonOperator)
{
case SCIMComparisonOperators.NE:
anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.NotEqual(attrInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrInteger);
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.NotEqual(attrDateTime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrDateTime);
anyStringLambda = Expression.Lambda <Func <string, bool> >(Expression.NotEqual(attrString, Expression.Constant(comparisonExpression.Value)), attrString);
anyBooleanLambda = Expression.Lambda <Func <bool, bool> >(Expression.NotEqual(attrBoolean, Expression.Constant(ParseBoolean(comparisonExpression.Value))), attrBoolean);
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.NotEqual(attrDecimal, Expression.Constant(ParseDecimal(comparisonExpression.Value))), attrDecimal);
anyBinaryLambda = Expression.Lambda <Func <byte[], bool> >(Expression.NotEqual(attrBinary, Expression.Constant(ParseBinary(comparisonExpression.Value))), attrBinary);
break;
case SCIMComparisonOperators.GT:
anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.GreaterThan(attrInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrInteger);
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.GreaterThan(attrDateTime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrDateTime);
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.GreaterThan(attrDecimal, Expression.Constant(ParseDecimal(comparisonExpression.Value))), attrDecimal);
break;
case SCIMComparisonOperators.GE:
anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.GreaterThanOrEqual(attrInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrInteger);
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.GreaterThanOrEqual(attrDateTime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrDateTime);
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.GreaterThanOrEqual(attrDecimal, Expression.Constant(ParseDecimal(comparisonExpression.Value))), attrDecimal);
break;
case SCIMComparisonOperators.LE:
anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.LessThanOrEqual(attrInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrInteger);
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.LessThanOrEqual(attrDateTime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrDateTime);
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.LessThanOrEqual(attrDecimal, Expression.Constant(ParseDecimal(comparisonExpression.Value))), attrDecimal);
break;
case SCIMComparisonOperators.LT:
anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.LessThan(attrInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrInteger);
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.LessThan(attrDateTime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrDateTime);
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.LessThan(attrDecimal, Expression.Constant(ParseDecimal(comparisonExpression.Value))), attrDecimal);
break;
case SCIMComparisonOperators.EQ:
anyIntegerLambda = Expression.Lambda <Func <int, bool> >(Expression.Equal(attrInteger, Expression.Constant(ParseInt(comparisonExpression.Value))), attrInteger);
anyDateTimeLambda = Expression.Lambda <Func <DateTime, bool> >(Expression.Equal(attrDateTime, Expression.Constant(ParseDateTime(comparisonExpression.Value))), attrDateTime);
anyStringLambda = Expression.Lambda <Func <string, bool> >(Expression.Equal(attrString, Expression.Constant(comparisonExpression.Value)), attrString);
anyBooleanLambda = Expression.Lambda <Func <bool, bool> >(Expression.Equal(attrBoolean, Expression.Constant(ParseBoolean(comparisonExpression.Value))), attrBoolean);
anyDecimalLambda = Expression.Lambda <Func <decimal, bool> >(Expression.Equal(attrDecimal, Expression.Constant(ParseDecimal(comparisonExpression.Value))), attrDecimal);
anyBinaryLambda = Expression.Lambda <Func <byte[], bool> >(Expression.NotEqual(attrBinary, Expression.Constant(ParseBinary(comparisonExpression.Value))), attrBinary);
break;
case SCIMComparisonOperators.SW:
var startWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
anyStringLambda = Expression.Lambda <Func <string, bool> >(Expression.Call(attrString, startWith, Expression.Constant(comparisonExpression.Value)), attrString);
break;
case SCIMComparisonOperators.EW:
var endWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
anyStringLambda = Expression.Lambda <Func <string, bool> >(Expression.Call(attrString, endWith, Expression.Constant(comparisonExpression.Value)), attrString);
break;
case SCIMComparisonOperators.CO:
var contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
anyStringLambda = Expression.Lambda <Func <string, bool> >(Expression.Call(attrString, contains, Expression.Constant(comparisonExpression.Value)), attrString);
break;
}
var allInteger = Expression.Call(typeof(Enumerable).GetMethods().First(m2 => m2.Name == "Any" && m2.GetParameters().Count() == 2).MakeGenericMethod(typeof(int)), propertyValuesInt, anyIntegerLambda);
var allDateTime = Expression.Call(typeof(Enumerable).GetMethods().First(m2 => m2.Name == "Any" && m2.GetParameters().Count() == 2).MakeGenericMethod(typeof(DateTime)), propertyValuesDateTime, anyDateTimeLambda);
var allString = Expression.Call(typeof(Enumerable).GetMethods().First(m2 => m2.Name == "Any" && m2.GetParameters().Count() == 2).MakeGenericMethod(typeof(string)), propertyValuesString, anyStringLambda);
var allBoolean = Expression.Call(typeof(Enumerable).GetMethods().First(m2 => m2.Name == "Any" && m2.GetParameters().Count() == 2).MakeGenericMethod(typeof(bool)), propertyValuesBoolean, anyBooleanLambda);
var allDecimal = Expression.Call(typeof(Enumerable).GetMethods().First(m2 => m2.Name == "Any" && m2.GetParameters().Count() == 2).MakeGenericMethod(typeof(decimal)), propertyValuesDecimal, anyDecimalLambda);
var allBinary = Expression.Call(typeof(Enumerable).GetMethods().First(m2 => m2.Name == "Any" && m2.GetParameters().Count() == 2).MakeGenericMethod(typeof(byte[])), propertyValuesBinary, anyBinaryLambda);
equalValue = Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.INTEGER)), allInteger),
Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.DATETIME)), allDateTime),
Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.STRING)), allString),
Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.BOOLEAN)), allBoolean),
Expression.Or(
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.DECIMAL)), allDecimal),
Expression.And(Expression.Equal(propertySchemaType, Expression.Constant(SCIMSchemaAttributeTypes.BINARY)), allBinary)
)
)
)
)
);
return(equalValue);
}
private static Expression BuildComparison(SCIMComparisonExpression comparisonExpression, MemberExpression representationExpr)
{
switch (comparisonExpression.ComparisonOperator)
{
case SCIMComparisonOperators.NE:
if (representationExpr.Type == typeof(DateTime))
{
return(Expression.NotEqual(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Expression.NotEqual(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(bool))
{
return(Expression.NotEqual(representationExpr, Expression.Constant(ParseBoolean(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(decimal))
{
return(Expression.NotEqual(representationExpr, Expression.Constant(ParseDecimal(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(byte[]))
{
return(Expression.NotEqual(representationExpr, Expression.Constant(ParseBinary(comparisonExpression.Value))));
}
return(Expression.NotEqual(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.GT:
if (representationExpr.Type == typeof(byte[]) || representationExpr.Type == typeof(bool))
{
throw new SCIMFilterException(string.Format(Global.GreaterThanNotSupported, representationExpr.Type.Name));
}
if (representationExpr.Type == typeof(DateTime))
{
return(Expression.GreaterThan(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Expression.GreaterThan(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(decimal))
{
return(Expression.GreaterThan(representationExpr, Expression.Constant(ParseDecimal(comparisonExpression.Value))));
}
return(Expression.GreaterThan(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.GE:
if (representationExpr.Type == typeof(byte[]) || representationExpr.Type == typeof(bool))
{
throw new SCIMFilterException(string.Format(Global.GreaterThanOrEqualNotSupported, representationExpr.Type.Name));
}
if (representationExpr.Type == typeof(DateTime))
{
return(Expression.GreaterThanOrEqual(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Expression.GreaterThanOrEqual(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(decimal))
{
return(Expression.GreaterThanOrEqual(representationExpr, Expression.Constant(ParseDecimal(comparisonExpression.Value))));
}
return(Expression.GreaterThanOrEqual(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.LE:
if (representationExpr.Type == typeof(byte[]) || representationExpr.Type == typeof(bool))
{
throw new SCIMFilterException(string.Format(Global.LessThanOrEqualNotSupported, representationExpr.Type.Name));
}
if (representationExpr.Type == typeof(DateTime))
{
return(Expression.LessThanOrEqual(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Expression.LessThanOrEqual(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(decimal))
{
return(Expression.LessThanOrEqual(representationExpr, Expression.Constant(ParseDecimal(comparisonExpression.Value))));
}
return(Expression.LessThanOrEqual(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.LT:
if (representationExpr.Type == typeof(byte[]) || representationExpr.Type == typeof(bool))
{
throw new SCIMFilterException(string.Format(Global.LessThanNotSupported, representationExpr.Type.Name));
}
if (representationExpr.Type == typeof(DateTime))
{
return(Expression.LessThan(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Expression.LessThan(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(decimal))
{
return(Expression.LessThan(representationExpr, Expression.Constant(ParseDecimal(comparisonExpression.Value))));
}
return(Expression.LessThan(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.EQ:
if (representationExpr.Type == typeof(DateTime))
{
return(Expression.Equal(representationExpr, Expression.Constant(ParseDateTime(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(int))
{
return(Expression.Equal(representationExpr, Expression.Constant(ParseInt(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(bool))
{
return(Expression.Equal(representationExpr, Expression.Constant(ParseBoolean(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(decimal))
{
return(Expression.Equal(representationExpr, Expression.Constant(ParseDecimal(comparisonExpression.Value))));
}
if (representationExpr.Type == typeof(byte[]))
{
return(Expression.Equal(representationExpr, Expression.Constant(ParseBinary(comparisonExpression.Value))));
}
return(Expression.Equal(representationExpr, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.SW:
var startWith = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });
return(Expression.Call(representationExpr, startWith, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.EW:
var endWith = typeof(string).GetMethod("EndsWith", new Type[] { typeof(string) });
return(Expression.Call(representationExpr, endWith, Expression.Constant(comparisonExpression.Value)));
case SCIMComparisonOperators.CO:
var contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
return(Expression.Call(representationExpr, contains, Expression.Constant(comparisonExpression.Value)));
}
return(null);
}
