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);