/// <summary>
/// Evaluates the type
/// </summary>
/// <param name="parser">QueryParser which evlauates the type</param>
/// <param name="currentValue">The current value.</param>
/// <param name="type">The type.</param>
/// <param name="currentCondition">The current condition.</param>
/// <returns>Boolean flag which indicates if the evaluation succedded</returns>
private bool EvaluateType(ref QueryParser parser,
object currentValue,
Type type,
QueryCondition currentCondition)
{
ObjectQueryEvaluator queryEvaluator = new ObjectQueryEvaluator();
bool result = false;
//check the field's type and call the evaluator.
if (parser.IsNumeric(type))
{
result = queryEvaluator.EvaluateNumeric(currentValue, currentCondition);
}
else if (parser.IsString(type))
{
result = queryEvaluator.EvaluateString(currentValue, currentCondition);
}
else if (parser.IsDateTime(type))
{
result = queryEvaluator.EvaluateDateTime(currentValue, currentCondition);
}
else if (parser.IsBool(type))
{
result = queryEvaluator.EvaluateBool(currentValue, currentCondition);
}
else
{
//try to evaluate a IComparable type
result = queryEvaluator.EvaluateIComparable(currentValue, type, currentCondition);
}
return(result);
}
/// <summary>
/// </summary>
/// <param name="dataSource"></param>
/// <param name="fieldName"></param>
/// <returns></returns>
public decimal Sum <T>(object dataSource, string fieldName)
{
ObjectQueryEvaluator objectEvaluator = null;
QueryParser parser = null;
ObjectReflection reflector = null;
decimal result = 0;
try
{
//check the subtype now
object value;
Type tp;
//it's generic object
objectEvaluator = new ObjectQueryEvaluator();
parser = new QueryParser();
reflector = new ObjectReflection();
T typeInstance = this.GetTypeInstance <T>(dataSource);
reflector.GetTypeOfField(typeInstance, fieldName, out tp, out value);
if (!parser.IsNumeric(tp))
{
throw new ArgumentException("Invalid type for property. Only numeric fields are accepted.");
}
else
{
IEnumerator ienum = ((IEnumerable)dataSource).GetEnumerator();
while (ienum.MoveNext())
{
reflector.GetTypeOfField((T)ienum.Current, fieldName, out tp, out value);
//add it to the result
result += Convert.ToDecimal(value);
}
}
return(result);
}
catch
{
throw;
}
}
/// <summary>
/// Evaluates the maximum value
/// </summary>
/// <param name="t">The t.</param>
/// <param name="dataSource">The data source.</param>
/// <param name="fieldName">Name of the field.</param>
/// <returns></returns>
public object EvaluateMax <T>(T t, object dataSource, string fieldName)
{
ObjectQueryEvaluator evaluator;
QueryParser parser = null;
try
{
evaluator = new ObjectQueryEvaluator();
parser = new QueryParser();
DataTable table = (DataTable)dataSource;
//look for the column name
int index = table.Columns.IndexOf(fieldName);
if (index == -1)
{
throw new ArgumentException("Invalid field name");
}
//clear the index fields
this.listIndexes.Clear();
if (parser.IsNumeric(table.Columns[index].DataType))
{
return((object)this.EvaluateNumeric(ref table, index, false));
}
else if (parser.IsDateTime(table.Columns[index].DataType))
{
return((object)this.EvaluateDateTime(ref table, index, false));
}
//since the DataTable types can't support IComparable it means we have a invalid column type
throw new ArgumentException("Invalid column type");
}
catch
{
throw;
}
}
