SearchExpression ToPascal(SearchExpression expression)
{
SearchOption <T> newSearchOption = new SearchOption <T>();
if (expression is PropertySearchExpression)
{
var propertyExpressionSearch = expression as PropertySearchExpression;
var asList = propertyExpressionSearch.Property.Split('_').ToList();
asList = asList.Select(a => a.First().ToString().ToUpper() + a.Substring(1, a.Length - 1)).ToList();
newSearchOption.Expression = new PropertySearchExpression()
{
Property = string.Join("", asList),
Operator = propertyExpressionSearch.Operator,
Value = propertyExpressionSearch.Value
};
}
if (expression is BinarySearchExpression <T> )
{
BinarySearchExpression <T> binarySearchExpression = expression as BinarySearchExpression <T>;
newSearchOption.Expression = new BinarySearchExpression <T>();
(newSearchOption.Expression as BinarySearchExpression <T>).LeftSearch = ToPascal(binarySearchExpression.LeftSearch);
(newSearchOption.Expression as BinarySearchExpression <T>).BinaryOperator = binarySearchExpression.BinaryOperator;
(newSearchOption.Expression as BinarySearchExpression <T>).RightSearch = ToPascal(binarySearchExpression.RightSearch);
}
return(newSearchOption.Expression);
}
//Match function built for repository that doesn't have projection power of search by default. Mearning search will be done after results are received
bool Match(T data, SearchExpression expression)
{
if (expression == null)
{
return(true);
}
if (expression is PropertySearchExpression)
{
int tempInt = 0;
double tempDouble = 0;
DateTime tempDatetime;
PropertySearchExpression propertySearchExpression = expression as PropertySearchExpression;
PropertyInfo pInfo = typeof(T).GetProperty(propertySearchExpression.Property);
var value = pInfo.GetValue(data);
switch (propertySearchExpression.Operator)
{
case "=": return((value ?? "").ToString().Trim().ToLower() == propertySearchExpression.Value.Trim().ToLower());
case "!=": return((value ?? "").ToString().Trim().ToLower() != propertySearchExpression.Value.Trim().ToLower());
case ">":
if (pInfo.GetType() == typeof(int) && int.TryParse(propertySearchExpression.Value, out tempInt))
{
return((int)value > tempInt);
}
if (pInfo.GetType() == typeof(double) && double.TryParse(propertySearchExpression.Value, out tempDouble))
{
return((double)value > tempDouble);
}
if (pInfo.GetType() == typeof(DateTime) && DateTime.TryParse(propertySearchExpression.Value, out tempDatetime))
{
return((DateTime)value > tempDatetime);
}
else
{
return(false);
}
case "<":
if (pInfo.GetType() == typeof(int) && int.TryParse(propertySearchExpression.Value, out tempInt))
{
return((int)value < tempInt);
}
if (pInfo.GetType() == typeof(double) && double.TryParse(propertySearchExpression.Value, out tempDouble))
{
return((double)value < tempDouble);
}
if (pInfo.GetType() == typeof(DateTime) && DateTime.TryParse(propertySearchExpression.Value, out tempDatetime))
{
return((DateTime)value < tempDatetime);
}
else
{
return(false);
}
case "%": return((value ?? "").ToString().Trim().ToLower().Contains(propertySearchExpression.Value.Trim().ToLower()));
default: return(false);
}
}
else
{
BinarySearchExpression <T> binarySearchExpression = expression as BinarySearchExpression <T>;
switch (binarySearchExpression.BinaryOperator)
{
case "||": return(Match(data, binarySearchExpression.LeftSearch) || Match(data, binarySearchExpression.RightSearch));
case "&&": return(Match(data, binarySearchExpression.LeftSearch) && Match(data, binarySearchExpression.RightSearch));
default: return(false);
}
}
}
static SearchExpression GetSearchExpression(Stack <Token> tokenList)
{
Stack <Token> output = new Stack <Token>();
bool error = false;
while ((tokenList.Count > 1 || tokenList.Count == 1 && tokenList.Peek().TokenType != TokenType.Expresssion))
{
Token token = tokenList.Pop();
if (token.TokenType == TokenType.BinaryOperator || token.TokenType == TokenType.AssignmentOperator)
{
Token rightHand = output.Pop();
Token leftHand = output.Pop();
ExpressionType expressionType = GetExpressionType(leftHand, rightHand, token);
if (expressionType == ExpressionType.member)
{
Token propertyExpressionToken = new Token();
PropertySearchExpression propertySearchExpression = new PropertySearchExpression();
propertySearchExpression.Property = leftHand.value as string;
propertySearchExpression.Operator = (string)token.value;
propertySearchExpression.Value = (string)rightHand.value;
propertyExpressionToken.value = propertySearchExpression;
propertyExpressionToken.TokenType = TokenType.Expresssion;
tokenList.Push(propertyExpressionToken);
while (output.Count > 0)
{
tokenList.Push(output.Pop());
}
}
else if (expressionType == ExpressionType.binary && leftHand.TokenType == TokenType.Expresssion && rightHand.TokenType == TokenType.Expresssion)
{
Token binaryExpressionToken = new Token();
BinarySearchExpression <T> binarySearchExpression = new BinarySearchExpression <T>();
binarySearchExpression.BinaryOperator = token.value as string;
binarySearchExpression.LeftSearch = leftHand.value as SearchExpression;
binarySearchExpression.RightSearch = rightHand.value as SearchExpression;
binaryExpressionToken.TokenType = TokenType.Expresssion;
binaryExpressionToken.value = binarySearchExpression;
tokenList.Push(binaryExpressionToken);
while (output.Count > 0)
{
tokenList.Push(output.Pop());
}
}
else
{
error = true;
break;
}
}
else
{
output.Push(token);
}
}
if (error || tokenList.Count > 1)
{
return(null);
}
return(tokenList.Pop().value as SearchExpression);
}
