/// <summary>
/// Transforms a raw parameters objects for basic query params of type T as well as optional
/// Filter Scaffold Filter params of type TK to the general used Query Parameters object
/// </summary>
/// <param name="generalQueryParameters"> The General Query Parameters describing general query properties( paging, sorting)</param>
/// <param name="filterScaffoldModel">The Filter Scaffold model providing the filtering information for the Query Paramters object </param>
/// <returns><see cref="QueryParameters"/> object that can be used by the main query processor</returns>
public QueryParameters ProcessParameters(T generalQueryParameters, FilterScaffoldModel <TE> filterScaffoldModel = null)
{
// Cast the general parameters object
var castGeneralQueryParameters = generalQueryParameters as JQueryDataTableParams;
var processedQueryParameters = new QueryParameters();
ProcessPagingParams(processedQueryParameters, castGeneralQueryParameters);
ProcessSortingParams(processedQueryParameters, castGeneralQueryParameters);
ProcessFilteringParams(processedQueryParameters, filterScaffoldModel);
return(processedQueryParameters);
}
public ActionResult ProcessDataTableRequest(JQueryDataTableParams dataTablesParam, FilterScaffoldModel <Document> filters)
{
// Profule the Document Querying functionality using mini profiler
var profiler = MiniProfiler.Current;
// Get the query params and process the query for the document queryable
var queryParams = _documentParamsProcessor.ProcessParameters(dataTablesParam, filters);
// Get and Profile the Documents Queryable collection
var documents = _documentRepository.ReadAllAsQueryable();
QueryResult <Document> queryProcessResult;
using (profiler.Step("Document Query Processing"))
{
queryProcessResult = _documentQueryProcessor.ProcessQuery(documents, queryParams);
}
// Get and Profile The execution of the queryable collection for documents
List <Document> queriedDocuments;
using (profiler.Step("Document Query Execution"))
{
queriedDocuments = queryProcessResult.ProcessedData.ToList();
}
var mappedDocuments = queriedDocuments.Select(Mapper.Map <AdminDocumentGridViewModel>).ToList();
JQueryDataTableResult jQueryResult = new JQueryDataTableResult()
{
aaData = mappedDocuments,
iTotalDisplayRecords = queryProcessResult.FilteredCount,
iTotalRecords = queryProcessResult.TotalCount,
sEcho = dataTablesParam.sEcho
};
return(Json(jQueryResult, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Create an HTML element for the Filter Node defined in the FilterScaffoldModel object.
///
/// </summary>
/// <param name="scaffoldModel"> The scaffold model containing the filter nodes </param>
/// <param name="nodeName"> The name of the node that we will be parsing and creating a filter ui element for </param>
/// <param name="createLabel">Flag indicating if the helper will wrap the filter input element in a parent also containing a label </param>
/// <param name="cssClasses"> A custom css class collection for the filter input element </param>
/// <returns>UI component referencing the string</returns>
public static MvcHtmlString DynamicFilterElement <T>(FilterScaffoldModel <T> scaffoldModel, string nodeName, bool createLabel, string cssClasses = "")
{
var node = scaffoldModel.GetLeafNodeByName(nodeName);
TagBuilder tagBuilder;
// determine the type of inputs
switch (node.FilterDataType)
{
case FilterDataType.String:
tagBuilder = FilterHtmlGeneralBuilders.FilterTextInput(cssClasses);
break;
case FilterDataType.Integer:
tagBuilder = FilterHtmlGeneralBuilders.FilterTextInput(cssClasses);
break;
case FilterDataType.Decimal:
tagBuilder = FilterHtmlGeneralBuilders.FilterTextInput(cssClasses);
break;
case FilterDataType.Date:
tagBuilder = FilterHtmlGeneralBuilders.FilterTextInput(cssClasses);
break;
case FilterDataType.SimpleDropdown:
tagBuilder = FilterHtmlGeneralBuilders.FilterSelectInput(cssClasses);
if (!node.IsDropdownClientPopulated)
{
PopulateServerDropdown(tagBuilder, node);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
// Add the generic filter input element class to the input
tagBuilder.AddCssClass("data-query-filter-input");
// Populate the attributes for the filter node / ui element
tagBuilder.AddAttribute("data-filter-data-type", node.FilterDataType.ToString());
// set the data type on the tag builder
tagBuilder.AddAttribute("data-dropdown-value-type", node.DropdownValueType.ToString());
tagBuilder.AddAttribute("data-filter-case", node.CaseSensitivity.ToString());
tagBuilder.AddAttribute("data-filter-operation-type", node.OperationType.ToString());
tagBuilder.AddAttribute("data-filter-operator", node.Operator.ToString());
tagBuilder.AddAttribute("data-filter-target", node.Target);
tagBuilder.AddAttribute("data-filter-label", node.Label);
tagBuilder.AddAttribute("id", node.Target);
// Add the fixed filter input class
tagBuilder.AddCssClass("query-filter-input");
return(new MvcHtmlString(tagBuilder.ToString()));
}
/// <summary>
/// Process filtering parameters from the FilterScaffoldModel if provided to the general Query Parameters object
/// </summary>
/// <param name="processedQueryParameters"></param>
/// <param name="filterScaffoldModel"></param>
private void ProcessFilteringParams(QueryParameters processedQueryParameters, FilterScaffoldModel <TE> filterScaffoldModel)
{
// If the filter scaffold model has not been provided we are going to ignore and return
if (filterScaffoldModel == null)
{
return;
}
// we are also checking the filter node collection on the filter scaffold model
if (filterScaffoldModel.FilterNodes == null || filterScaffoldModel.FilterNodes.Count == 0)
{
return;
}
// if everything passes go and process each filter node individually
foreach (var scaffoldFilterNode in filterScaffoldModel.FilterNodes)
{
// only add the filter node if it is a root node that has at least one leaf node
// or it is a leaf node that has a set value
if (scaffoldFilterNode is FilterLeafNode)
{
// Check if the leaf node value is set to anything and is not a default value
var nodeAsLeaf = scaffoldFilterNode as FilterLeafNode;
// check if the value for the leaf node is not null
// for object values we are hardly going to get an strongly typed value type so we can ignore value type checks
if (nodeAsLeaf.Value != null)
{
processedQueryParameters.Filters.Add(scaffoldFilterNode);
}
}
else
{
// Scaffold Filte Node is a Root Node
var nodeAsRoot = scaffoldFilterNode as FilterRootNode;
if (nodeAsRoot != null && (nodeAsRoot.Nodes != null && nodeAsRoot.Nodes.Count > 0))
{
// add the root node
processedQueryParameters.Filters.Add(scaffoldFilterNode);
}
}
}
}
/// <summary>
/// Return a filter scaffold model object with properties mapped from the Entntiy
/// that the filter scaffolder is based on
/// </summary>
/// <returns></returns>
public static FilterScaffoldModel <T> GetFilterScaffoldModel <T>()
{
var filterScaffold = new FilterScaffoldModel <T>();
return(filterScaffold);
}
