/// <summary>
/// Converts an ag-grid FilterEntry into UniversalFilterEntry
/// </summary>
/// <param name="filterEntry">The ag-grid entry to convert</param>
/// <returns>An UniversalFilterEntry instance or null if the data values in the FilterEntry instance couldn't be parsed.</returns>
/// <remarks>Only non-parsable data cause null to be returned, in other cases an exception is thrown</remarks>
static public UniversalFilterEntry Convert(FilterEntry filterEntry)
{
UniversalFilterEntry r = new UniversalFilterEntry();
r.FilterOperator = FilterOperatorParser.filterOperators[filterEntry.type];
try
{
if (filterEntry.filterType == "text")
{
r.FirstValue = filterEntry.filter;
r.SecondValue = null;
}
else if (filterEntry.filterType == "date")
{
r.FirstValue = DateTime.ParseExact(filterEntry.dateFrom, "yyyy-MM-dd", CultureInfo.InvariantCulture);
if (String.IsNullOrEmpty(filterEntry.dateTo) == false)
{
r.SecondValue = DateTime.ParseExact(filterEntry.dateTo, "yyyy-MM-dd", CultureInfo.InvariantCulture);
}
}
else if (filterEntry.filterType == "number")
{
r.FirstValue = double.Parse(filterEntry.filter, CultureInfo.CurrentCulture);
if (String.IsNullOrEmpty(filterEntry.filterTo) == false)
{
r.SecondValue = double.Parse(filterEntry.filterTo, CultureInfo.CurrentCulture);
}
}
else if (filterEntry.filterType == "boolean")
{
r.FirstValue = bool.Parse(filterEntry.filter);
}
else
{
throw new InvalidOperationException(String.Format("The filter type {0} is not supported.", filterEntry.filterType));
}
}
catch (InvalidOperationException)
{
throw;
}
catch (Exception)
{
r = null;
}
return(r);
}
public ActionResult Page(int startRow, int endRow, SortEntry[] sortModel, Dictionary <string, FilterEntry> filterModel, string globalFilter)
{
IQueryable <Connection> query = connectionRepository.GetConnections();
// if filters aren't posted, in filters we get values from MVC; with "action", "controller" as keys; they must be excluded, currently by their null value criterion
foreach (var kvp in filterModel.Where(x => x.Value != null))
{
// get expression for this column
LambdaExpression columnExpression = columnSource[kvp.Key];
// convert grid-specific filter to an universal entry
UniversalFilterEntry universalFilterEntry = FilterEntryConverter.Convert(kvp.Value);
// check whether the entry was parsed successfully
if (universalFilterEntry == null)
{
continue;
}
// get the fltering expression from universalFilterEntry
Expression <Func <Connection, bool> > filterExpression = FilterExpressions <Connection> .GetFilterExpression(columnExpression, universalFilterEntry);
// and apply it to the query
query = query.Where(filterExpression);
}
// global filtering
if (String.IsNullOrWhiteSpace(globalFilter) == false)
{
query = query.Where(x => x.Name.Contains(globalFilter) || x.PPE.Contains(globalFilter) || x.MeterCode.Contains(globalFilter) || x.Company.Acronym.Contains(globalFilter) || x.Tariff.Name.Contains(globalFilter));
}
int count = query.Count();
if (sortModel != null)
{
for (int i = 0; i < sortModel.Length; i++)
{
SortEntry sortEntry = sortModel[i];
string column = sortEntry.colId;
bool isAsc = sortEntry.sort == SortEntry.asc;
bool isFirst = i == 0;
LambdaExpression columnExpression = columnSource[column];
query = SortHelper.ApplyOrderByFromLambda(query, columnExpression, isAsc, isFirst);
}
}
else
{
query = query.OrderBy(x => x.Name);
}
var r = query.Skip(startRow).Take(endRow - startRow).Select(x =>
new
{
id = x.Id,
ppe = x.PPE,
meterCode = x.MeterCode,
name = x.Name,
tariff = x.Tariff.Name,
company = x.Company.Acronym,
startDate = x.StartDate,
endDate = x.EndDate,
orderedCapacity = x.OrderedCapacity,
endDateNullable = x.EndDate,
orderedCapacityNullable = x.OrderedCapacity,
isActive = x.Name.Length % 2 == 0 // fake boolean column
}).ToArray();
var response = new { rows = r, count = count };
return(new JsonNetResult(response));
}
