Expression ICustomFunctionOperatorConvertibleToExpression.Convert(ICriteriaToExpressionConverter converter, params Expression[] operands)
{
ConstantExpression typeNameExpr = operands[1] as ConstantExpression;
ConstantExpression propertyNameExpr = operands[2] as ConstantExpression;
if (typeNameExpr == null)
{
throw new ArgumentException("The Upcast function expects a constant as the second argument (type name).");
}
if (propertyNameExpr == null)
{
throw new ArgumentException("The Upcast function expects a constant as the third argument (property name).");
}
string typeName = typeNameExpr.Value as string;
string propertyName = propertyNameExpr.Value as string;
if (string.IsNullOrWhiteSpace(typeName))
{
throw new ArgumentException("The type name parameter is not a string value or an empty string");
}
if (string.IsNullOrWhiteSpace(propertyName))
{
throw new ArgumentException("The property name parameter is not a string value or an empty string");
}
Type type = GetTypeByName(typeName);
return(Expression.Property(
Expression.Convert(operands[0], type),
propertyName
));
}
Expression ICustomAggregateConvertibleToExpression.Convert(ICriteriaToExpressionConverter converter, Expression collectionProperty, ParameterExpression elementParameter, params Expression[] operands)
{
Type callFrom;
if (typeof(ParallelQuery).IsAssignableFrom(collectionProperty.Type))
{
callFrom = typeof(ParallelEnumerable);
}
else
{
callFrom = typeof(Enumerable);
}
Expression operand = Expression.Convert(operands[0], typeof(double));
Expression operandPower2 = Expression.Call(typeof(Math), "Pow", new Type[] { }, operand, Expression.Constant(2.0));
Expression sumOfSquares = Expression.Call(callFrom, "Sum", new Type[] { elementParameter.Type }, collectionProperty, Expression.Lambda(operandPower2, elementParameter));
Expression sum = Expression.Call(callFrom, "Sum", new Type[] { elementParameter.Type }, collectionProperty, Expression.Lambda(operand, elementParameter));
Expression count = Expression.Call(callFrom, "Count", new Type[] { elementParameter.Type }, collectionProperty);
count = Expression.Convert(count, typeof(double));
Expression sumOfSquaresDivide2 = Expression.Divide(sumOfSquares, count);
Expression sumDivideCountPower2 = Expression.Call(typeof(Math), "Pow", new Type[] { }, Expression.Divide(sum, count), Expression.Constant(2.0));
Expression subtract = Expression.Subtract(sumOfSquaresDivide2, sumDivideCountPower2);
return(Expression.Call(typeof(Math), "Sqrt", new Type[] { }, subtract));
}
Expression ICustomFunctionOperatorConvertibleToExpression.Convert(ICriteriaToExpressionConverter converter, params Expression[] operands)
{
if (operands.Length != 2)
{
throw new ArgumentException("operands.Length != 2");
}
if (converter is CriteriaToEFExpressionConverter || converter is CriteriaToEFExpressionConverterInternal)
{
return(LikeFunction.MakeLinq(converter, operands[0], operands[1]));
}
return(((ICustomFunctionOperatorConvertibleToExpression)LikeFunction.Original).Convert(converter, operands));
}
Expression ICustomAggregateConvertibleToExpression.Convert(ICriteriaToExpressionConverter converter, Expression collectionProperty, ParameterExpression elementParameter, params Expression[] operands)
{
Type callFrom;
if (typeof(ParallelQuery).IsAssignableFrom(collectionProperty.Type))
{
callFrom = typeof(ParallelEnumerable);
}
else
{
callFrom = typeof(Enumerable);
}
var lambda = Expression.Lambda(operands[0], elementParameter);
var selectCall = Expression.Call(callFrom, "Select", new Type[] { elementParameter.Type, operands[0].Type }, collectionProperty, lambda);
var distinctCall = Expression.Call(callFrom, "Distinct", new Type[] { operands[0].Type }, selectCall);
return(Expression.Call(callFrom, "Count", new Type[] { operands[0].Type }, distinctCall));
}
Expression ICustomFunctionOperatorConvertibleToExpression.Convert(ICriteriaToExpressionConverter converter, Expression[] operands)
{
if (operands.Length != 2)
{
throw new ArgumentException("operands.Length != 2");
}
if (operands[0].NodeType == ExpressionType.Constant)
{
string str = ((ConstantExpression)operands[0]).Value?.ToString();
if (str == null)
{
return Expression.Constant(false);
}
var like = typeof(niterModel.Store.Extension).GetMethod("LikeFnc", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
return Expression.Call(null, like, new Expression[] { EvalHelpers.SafeToString(operands[1]), Expression.Constant(str) });
}
return Expression.Call(EvalHelpers.SafeToString(operands[0]), "Contains", (Type[])null, new Expression[] { EvalHelpers.SafeToString(operands[1]) });
}
public Expression Convert(CriteriaOperatorCollection operands, ParameterExpression thisExpression, ICriteriaToExpressionConverter converter)
{
Type elementType = GetElementType(thisExpression);
ParameterExpression elementParameter = Expression.Parameter(elementType, "elem");
LambdaExpression groupSelect = Expression.Lambda(converter.Convert(elementParameter, operands[1]), elementParameter);
Expression groupEpression = Expression.Call(typeof(Enumerable), "GroupBy", new Type[] { elementType, groupSelect.Body.Type }, thisExpression, groupSelect);
return(Expression.Call(typeof(Enumerable), "Count", new Type[] { groupEpression.Type.GetGenericArguments()[0] }, groupEpression));
}
static Expression MakeLinq(ICriteriaToExpressionConverter converter, Expression vExpr, Expression pExpr)
{
if (pExpr.NodeType == ExpressionType.Constant)
{
object boxedVal = ((ConstantExpression)pExpr).Value;
string pattern = boxedVal != null?boxedVal.ToString() : null;
if (pattern == null)
{
return(Expression.Constant(false));
}
string body = pattern;
bool lastPercent = body.EndsWith("%");
if (lastPercent)
{
body = body.Substring(0, body.Length - 1);
}
bool firstPercent = body.StartsWith("%");
if (firstPercent)
{
body = body.Substring(1);
}
if (!body.Contains('%') && !body.Contains('_') && !body.Contains('[') && (lastPercent || firstPercent))
{
var stringExpr = EvalHelpers.SafeToString(vExpr);
{
var maybeIifConverter = converter as CriteriaToExpressionConverterInternal;
if (maybeIifConverter != null && maybeIifConverter.ForceIifForInstance)
{
Expression <Func <string, bool> > method;
if (!firstPercent)
{
method = s => s != null?s.StartsWith(body) : false;
}
else if (!lastPercent)
{
method = s => s != null?s.EndsWith(body) : false;
}
else
{
method = s => s != null?s.Contains(body) : false;
}
return(Expression.Invoke(Expression.Constant(method), stringExpr));
}
}
string methodName;
if (!firstPercent)
{
methodName = "StartsWith";
}
else if (!lastPercent)
{
methodName = "EndsWith";
}
else
{
methodName = "Contains";
}
return(Expression.Call(stringExpr, methodName, null, Expression.Constant(body)));
}
}
return(((ICustomFunctionOperatorConvertibleToExpression)LikeFunction.Original).Convert(converter, vExpr, pExpr));
}
Expression ICustomFunctionOperatorConvertibleToExpression.Convert(ICriteriaToExpressionConverter converter, params Expression[] operands)
{
object currentUserDepartment = ((ICustomPermissionPolicyUser)SecuritySystem.CurrentUser).Department;
return(Expression.Constant(currentUserDepartment));
}
