Description

DataUtil is a static class which provides a set of helper functions for querying local data - array of JavaScript objects. It can be used for applying data operations like - filtering, sorting, paging.

API Methods

Name	Description
sort	Takes as arguments array of JavaScript objects(on which sorting is applied) and object of type SortingState. The method returns sorted data. Object of type SortingState is used to configure which column(s) to sort,sorting direction, sorting algorithm.
filter	Takes as arguments array of JavaScript objects(on which filtering should be applied) and object of type FilteringState. Returns filtered data(array of JavaScript objects). Object of type FilteringState is used to configure which column(s) to filter, search value, filtering algorithm.
page	Takes as arguments array of JavaScript objects and object of type PagingState. Returns paginated data. Object of type PagingState is used to configure how paging should be applied - which is the current page, records per page. NOTE: This method validates input arguments(e.g. page index should be positive number) and calculates number of pages. The result is saved in property of PagingState - metadata.
process	Takes as arguments array of JavaScript objects and object of type DataState and applies sorting/paging/filtering. Returns transformed data. Object of type DataState is used to configure which data-querying operation to be applied.

Usage

Code in .ts demonstrating how to use function process:

items: Array<Object> = [
            { id: 1, text: "Item 1" },
            { id: 2, text: "Item 2" },
            { id: 3, text: "Item 3" },
            { id: 4, text: "Item 4" },
            { id: 5, text: "Item 5" },
            { id: 6, text: "Item 6" }
        ];
// apply filtering, sorting and paging
        state:DataState = {
                    filtering: {
                        expressions: [{
                            fieldName: "id", 
                            condition: FilteringCondition.number.greaterThan, 
                            searchVal: 1}]
                    },
                    sorting: {
                            expressions: [
                                {
                                    fieldName: "text",
                                    dir: SortingDirection.Desc
                                }
                            ]
                        },
                    paging: {
                        index: 0,
                        recordsPerPage: 2
                    }
                };
        let res = DataUtil.process(items, state);

Additional interfaces, enums and classes used in DataUtil

• SortingState - interface, which defines how sorting should be applied. Its properties are:

  • expressions - array of objects of type SortingExpression. It defines which column(s) should be sorted, order of sorted columns and sorting direction.
  • strategy - object of type SortingStrategy. It represents sorting algorithm. (optional)

• FilteringState - interface, which defines how filtering should be applied. Its properties are:

  • expressionsTree - object of type IFilteringExpressionsTree. It defines which column(s) should be filtered, filtering conditions, filtering logic and (if any)search value on which filtering should be applied.
  • strategy - object of type FilteringStrategy. It represents filtering algorithm. (optional)

• PagingState - interface, which defines how paging should be applied. Its properties are:

  • index - identifies current page index(0 based positive number)
  • recordsPerPage - identifies count of records per page.
  • metadata - object which holds metadata information about paging(optional). Its properties are:
    • countPages
    • error - enum of type PagingError. Possible values are - PagingError.None, PagingError.IncorrectPageIndex, PagingError.IncorrectRecordsPerPage
    • countRecords - total count of records

• SortingExpression - interface which defines how sorting should be applied per column. Its properties are:

  • fieldName - specifies name of the column
  • dir - identifies sorting direction. It is of type enum SortingDirection. Possible options are SortingDirection.Asc and SortingDirection.Desc
  • ignoreCase - boolean property which identifies whether sorting is case-sensitive for string columns(optional)

• FilteringExpression - interface which defines how filtering should be applied for each column. Its properties are:

  • fieldName - specifies name of the column
  • condtion - specifies filtering condition. It should be function which accepts as arguments:
    • value - value of the record on which filtering is applied
    • searchVal - search value. There are filtering conditions which do not require searchVal. Example - FilteringCondition.Boolean.True.(optional)
    • ignoreCase - boolean variable which specifies case-sensitivity for string columns(optional)
  • searchVal - specifies value to search for.(optional)
  • ignoreCase - boolean variable which specifies case-sensitivity for string columns(optional)

• FilteringExpressionsTree - class which implements IFilteringExpressionsTree interface. Describes the filtering state of a grid/column. Its properties and methods are:

  • filteringOperands - an array of IFilteringExpressionsTree or IFilteringExpression objects which has the same filtering logic. If applied to a grid each object describes the filtering state of a grid's column. If applied to a column each object describes one filtering expression or a branch with filtering expressions with complex filtering logic.
  • operator - object of type FilteringLogic. Defines the filtering logic for all objects in filteringOperands property.
  • fieldName - (optional). Should not be set on a grid's level. It should be set for each FilteringExpressionsTree in the grid's filterOperands. That's how the filtering state for each column is defined.
  • find(fieldName: string) - Returns the filtering state for a given column. Return type could be IFilteringExpressionsTree or IFilteringExpression.
  • findIndex(fieldName: string) - Returns the index of the filtering state for a given column.

• SortingStrategy - class which implements ISortingStrategy interface. It specifies sorting algorithm.

• FilteringStrategy - class which implements IFilteringStrategy interface. It specifies filtering algorithm.

• FilteringLogic - class which describes the filtering logic between the different filtering expressions. Its values are FilteringLogic.And, FilteringLogic.Or.

• GridColumnDataType - enumeration which represent basic data types. Its values are:

  • GridColumnDataType.Boolean
  • GridColumnDataType.Date
  • GridColumnDataType.Number
  • GridColumnDataType.String