public void NullRequestResponseCreation()
{
// Arrange
Core.IDataTablesRequest request = null;
// Act
var response = request.CreateResponse("just_some_error_message");
// Assert
Assert.Null(response);
}
public static IEnumerable <T> Compute <T>(this IEnumerable <T> data, Core.IDataTablesRequest request,
out int filteredDataCount)
{
filteredDataCount = 0;
if (!data.Any() || request == null)
{
return(data);
}
// Global filtering.
// Filter is being manually applied due to in-memmory (IEnumerable) data.
// If you want something rather easier, check IEnumerableExtensions Sample.
// var filteredData = data.Where(_item => _item.Hostname.Contains(request.Search.Value));
var filteredData = Enumerable.Empty <T>();
// Inutile de faire une recherche s'il n'y a rien à chercher.
if (!string.IsNullOrEmpty(request.Search.Value))
{
var filteredColumn = request.Columns.Where(c => c.IsSearchable);
filteredData = filteredColumn.Select(sColumn =>
data.First()
.GetType()
.GetProperty(sColumn.Name, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance))
.Select(propertyInfo => data.PropertyContains(propertyInfo, request.Search.Value))
.Aggregate(filteredData, (current, columnResult) => current.Concat(columnResult));
// Pour éviter les doublons
filteredData = filteredData.Distinct();
}
else
{
filteredData = data;
}
// Ordering filtred data
var orderedColumn = request.Columns.Where(c => c.IsSortable && c.Sort != null);
filteredData = orderedColumn.Aggregate(filteredData, (current, sColumn) => current.OrderBy(sColumn));
// Paging filtered data.
// Paging is rather manual due to in-memmory (IEnumerable) data.
// var dataPage = filteredData.OrderBy(d => d.ID).Skip(request.Start);
var dataPage = filteredData.Skip(request.Start);
if (request.Length != -1)
{
dataPage = dataPage.Take(request.Length);
}
filteredDataCount = filteredData.Count();
return(dataPage);
}
/// <summary>
/// Creates a new response instance.
/// </summary>
/// <param name="request">The request object.</param>
/// <param name="errorMessage">Error message.</param>
/// <returns>The response object.</returns>
public static DataTablesResponse Create(Core.IDataTablesRequest request, string errorMessage, IDictionary <string, object> additionalParameters)
{
// When request is null, there should be no response (null response).
if (request == null)
{
return(null);
}
if (DataTables.AspNet.Mvc5.Configuration.Options.IsDrawValidationEnabled)
{
// When draw validation is in place, response must have a draw value equals to or greater than 1.
// Any other value besides that represents an invalid draw request and response should be null.
if (request.Draw < 1)
{
return(null);
}
}
return(new DataTablesResponse(request.Draw, errorMessage, additionalParameters));
}
/// <summary>
/// This is your data method.
/// DataTables will query this (HTTP GET) to fetch data to display.
/// </summary>
/// <param name="request">
/// This represents your DataTables request.
/// It's automatically binded using the default binder and settings.
///
/// You should use IDataTablesRequest as your model, to avoid unexpected behavior and allow
/// custom binders to be attached whenever necessary.
/// </param>
/// <returns>
/// Return data here, with a json-compatible result.
/// </returns>
public IActionResult PageData(Core.IDataTablesRequest request)
{
// Nothing important here. Just creates some mock data.
var data = Models.SampleEntity.GetSampleData();
// Global filtering.
// Filter is being manually applied due to in-memmory (IEnumerable) data.
// If you want something rather easier, check IEnumerableExtensions Sample.
var filteredData = String.IsNullOrWhiteSpace(request.Search.Value)
? data
: data.Where(_item => _item.Name.Contains(request.Search.Value));
// Paging filtered data.
// Paging is rather manual due to in-memmory (IEnumerable) data.
var dataPage = filteredData.Skip(request.Start).Take(request.Length);
// Response creation. To create your response you need to reference your request, to avoid
// request/response tampering and to ensure response will be correctly created.
var response = DataTablesResponse.Create(request, data.Count(), filteredData.Count(), dataPage);
// Easier way is to return a new 'DataTablesJsonResult', which will automatically convert your
// response to a json-compatible content, so DataTables can read it when received.
return(new DataTablesJsonResult(response, true));
}
/// <summary>
/// Creates a new response instance.
/// </summary>
/// <param name="request">The request object.</param>
/// <param name="errorMessage">Error message.</param>
/// <returns>The response object.</returns>
public static DataTablesResponse Create(Core.IDataTablesRequest request, string errorMessage)
{
return(DataTablesResponse.Create(request, errorMessage, null));
}
/// <summary>
/// Creates a new response instance.
/// </summary>
/// <param name="request">The request object.</param>
/// <param name="totalRecords">Total record count (total records available on database).</param>
/// <param name="totalRecordsFiltered">Filtered record count (total records available after filtering).</param>
/// <param name="data">Data object (collection).</param>
/// <returns>The response object.</returns>
public static DataTablesResponse Create(Core.IDataTablesRequest request, int totalRecords, int totalRecordsFiltered, object data)
{
return(DataTablesResponse.Create(request, totalRecords, totalRecordsFiltered, data, null));
}
/// <summary>
/// Creates a DataTables response object.
/// </summary>
/// <param name="request">The DataTables request object.</param>
/// <param name="totalRecords">Total records count (total available non-filtered records on database).</param>
/// <param name="totalRecordsFiltered">Total filtered records (total available records after filtering).</param>
/// <param name="data">Data object (collection).</param>
/// <param name="additionalParameters">Adicional parameters dictionary.</param>
/// <returns>A DataTables response object.</returns>
public static Core.IDataTablesResponse CreateResponse(this Core.IDataTablesRequest request, int totalRecords, int totalRecordsFiltered, object data, IDictionary <string, object> additionalParameters)
{
return(DataTablesResponse.Create(request, totalRecords, totalRecordsFiltered, data, additionalParameters));
}
/// <summary>
/// Creates a DataTables response object.
/// </summary>
/// <param name="request">The DataTables request object.</param>
/// <param name="errorMessage">Error message to send back to client-side.</param>
/// <param name="additionalParameters">Aditional parameters dictionary.</param>
/// <returns>A DataTables response object.</returns>
public static Core.IDataTablesResponse CreateResponse(this Core.IDataTablesRequest request, string errorMessage, IDictionary <string, object> additionalParameters)
{
return(DataTablesResponse.Create(request, errorMessage, additionalParameters));
}
/// <summary>
/// Creates a DataTables response object.
/// </summary>
/// <param name="request">The DataTables request object.</param>
/// <param name="errorMessage">Error message to send back to client-side.</param>
/// <returns>A DataTables response object.</returns>
public static Core.IDataTablesResponse CreateResponse(this Core.IDataTablesRequest request, string errorMessage)
{
return(request.CreateResponse(errorMessage, null));
}
public static DataTablesResponse ToDataSourceResult <TModel, TResult>(this List <TModel> queryable, Core.IDataTablesRequest request, Func <TModel, TResult> selector)
{
if (request == null)
{
return(null);
}
if (Configuration.Options.IsDrawValidationEnabled)
{
if (request.Draw < 1)
{
return(null);
}
}
return(queryable.AsQueryable <TModel>().CreateDataSourceResult <TModel, TResult>(request, null, selector));
}
private static DataTablesResponse CreateDataSourceResult <TModel, TResult>(this IQueryable <TModel> queryable, Core.IDataTablesRequest request, ModelStateDictionary modelState, Func <TModel, TResult> selector)
{
if (queryable?.Any() != true || request.Length == 0)
{
return(default);
