Final Class: IndexerModelTreeDataProvider

Oracle® JavaScript Extension Toolkit (JET)
12.1.0
F52696-01

Since:
  • 7.0
Module:
  • ojindexermodeltreedataprovider

QuickNav

Methods

Type Definitions

Description

TreeDataProvider and IndexerModel implementation that represents hierachical data available from an array of JSON objects. This DataProvider can be used by Indexer and its associated ListView.

See the Indexer - Basic demo for an example.

Refer to TreeDataProvider for other data providers that represent hierarachical data.


Usage

Signature:

final class IndexerModelTreeDataProvider<K, D> implements IndexerModel, TreeDataProvider<K, D>

Generic Parameters
ParameterDescription
KType of Key
DType of Data
Typescript Import Format
//This class is exported directly as module. To import it
import IndexerModelTreeDataProvider= require("ojs/ojindexermodeltreedataprovider");

For additional information visit:


Final classes in JET

Classes in JET are generally final and do not support subclassing. At the moment, final is not enforced. However, this will likely change in an upcoming JET release.


Constructor

new IndexerModelTreeDataProvider(data, options)

Implementation of the IndexerModel and TreeDataProvider based on an array of data set. This should be used with the Indexer and its associated ListView. By default, this DataProvider groups the data based on the first letter of the data and the alphabet of the current locale. Note this implementation of TreeDataProvider does not fire any model events.
Parameters:
Name Type Argument Description
data Array.<any> an array of data used for Indexer and ListView
options IndexerModelTreeDataProvider.Options.<D> <optional>
 the options set on this IndexerModelTreeProvider

Methods

addEventListener(eventType: string, listener: EventListener): void

Add a callback function to listen for a specific event type.
Parameters:
Name Type Description
eventType string The event type to listen for.
listener EventListener The callback function that receives the event notification.

containsKeys(parameters : FetchByKeysParameters<K>) : Promise<ContainsKeysResults<K>>

Check if there are rows containing the specified keys
Parameters:
Name Type Description
parameters FetchByKeysParameters contains by key parameters
Since:
  • 4.2.0
Returns:
Returns Promise which resolves to ContainsKeysResults.
Type
Promise.<ContainsKeysResults>
Example

Check if keys 1001 and 556 are contained

let containsKeys = [1001, 556];
let value = await dataprovider.containsKeys({keys: containsKeys});
let results = value['results'];
if (results.has(1001)) {
  console.log('Has key 1001');
} else if (results.has(556){
  console.log('Has key 556');
}

dispatchEvent(evt: Event): boolean

Dispatch an event and invoke any registered listeners.
Parameters:
Name Type Description
event Event The event object to dispatch.
Returns:
Return false if a registered listener has cancelled the event. Return true otherwise.
Type
boolean

fetchByKeys(parameters : FetchByKeysParameters<K>) : Promise<FetchByKeysResults<K, D>>

Fetch rows by keys
Parameters:
Name Type Description
parameters FetchByKeysParameters fetch by key parameters
Since:
  • 4.2.0
Returns:
Returns Promise which resolves to FetchByKeysResults.
Type
Promise.<FetchByKeysResults>
Example

Fetch for keys 1001 and 556

let fetchKeys = [1001, 556];
let value = await dataprovider.fetchByKeys({keys: fetchKeys});
// get the data for key 1001
console.log(value.results.get(1001).data);

fetchByOffset(parameters: FetchByOffsetParameters<D>): Promise<FetchByOffsetResults<K, D>>

Fetch rows by offset

A generic implementation of this method is available from FetchByOffsetMixin. It is for convenience and may not provide the most efficient implementation for your data provider. Classes that implement the DataProvider interface are encouraged to provide a more efficient implementation.

Parameters:
Name Type Description
parameters FetchByOffsetParameters fetch by offset parameters
Since:
  • 4.2.0
Returns:
Returns Promise which resolves to FetchByOffsetResults.
Type
Promise.<FetchByOffsetResults>
Example

Fetch by offset 5 rows starting at index 2

let result = await dataprovider.fetchByOffset({size: 5, offset: 2});
let results = result['results'];
let data = results.map(function(value) {
  return value['data'];
});
let keys = results.map(function(value) {
  return value['metadata']['key'];
});

fetchFirst(parameters?: FetchListParameters<D>): AsyncIterable<FetchListResult<K, D>>

Get an AsyncIterable object for iterating the data.

AsyncIterable contains a Symbol.asyncIterator method that returns an AsyncIterator. AsyncIterator contains a “next” method for fetching the next block of data.

The "next" method returns a promise that resolves to an object, which contains a "value" property for the data and a "done" property that is set to true when there is no more data to be fetched. The "done" property should be set to true only if there is no "value" in the result. Note that "done" only reflects whether the iterator is done at the time "next" is called. Future calls to "next" may or may not return more rows for a mutable data source.

In order for JET components to work correctly, DataProvider implementations should ensure that:

  • The iterator accounts for data mutations when returning the next block of data, and that no row is duplicated or skipped. For example, an offset-based implementation may need to adjust the offset from which the next block of data starts if rows have been added or removed in the returned data.
  • JET components may call "next" on the iterator even after the iterator has returned done:true. If new data is available after the last returned row, the iterator is expected to return the new data and set "done" to false. This differs from the AsyncIterator spec for performance reasons.

Please see the DataProvider documentation for more information on custom implementations.

Parameters:
Name Type Argument Description
params FetchListParameters <optional>
 fetch parameters
Since:
  • 4.2.0
See:
Returns:
AsyncIterable with FetchListResult
Type
AsyncIterable.<FetchListResult>
Example

Get an asyncIterator and then fetch first block of data by executing next() on the iterator. Subsequent blocks can be fetched by executing next() again.

let asyncIterator = dataprovider.fetchFirst(options)[Symbol.asyncIterator]();
let result = await asyncIterator.next();
let value = result.value;
let data = value.data;
let keys = value.metadata.map(function(val) {
  return val.key;
});

getCapability(capabilityName: string): any

Determines whether this DataProvider defines a certain feature.
Parameters:
Name Type Description
capabilityName string capability name. Defined capability names are: "fetchByKeys", "fetchByOffset", "sort", "fetchCapability" and "filter".
Since:
  • 4.2.0
Returns:
capability information or null if undefined
Type
Object
Example

Check what kind of fetchByKeys is defined.

let capabilityInfo = dataprovider.getCapability('fetchByKeys');
if (capabilityInfo.implementation == 'iteration') {
  // the DataProvider supports iteration for fetchByKeys
  ...

getChildDataProvider(parentKey: K): TreeDataProvider<K, D> | null

Get the data provider for the children of the row identified by parentKey.
Parameters:
Name Type Description
parentKey any key of the row to get child data provider for.
Since:
  • 5.1.0
Returns:
A TreeDataProvider if the row can (but doesn't have to) have children; or null if the row cannot have children. Use the isEmpty method on the returned TreeDataProvider to determine if it currently has children.
Type
TreeDataProvider | null

getIndexableSections(): IndexerModel.Section[]

Returns an array of objects each representing a section in the associated ListView.
Returns:
an array of all indexable sections
Type
Array.<string> | Array.<Object>

getMissingSections(): IndexerModel.Section[]

Returns an array of objects each representing a section that does not have a corresponding section in the associated ListView. It must be a subset of the return value of getIndexableSections. Return null or undefined if there's nothing missing.
Returns:
an array of missing sections
Type
Array.<string> | Array.<Object>

getTotalSize : {Promise.<number>}

Return the total number of rows in this dataprovider
Returns:
Returns a Promise which resolves to the total number of rows. -1 is unknown row count.
Type
Promise.<number>
Example

Get the total rows

let value = await dataprovider.getTotalSize();
if (value == -1) {
  // we don't know the total row count
} else {
  // the total count
  console.log(value);
}

isEmpty(): 'yes' | 'no' | 'unknown'

Returns a string that indicates if this data provider is empty. Valid values are:
  • "yes": this data provider is empty.
  • "no": this data provider is not empty.
  • "unknown": it is not known if this data provider is empty until a fetch is made.
Since:
  • 4.2.0
Returns:
string that indicates if this data provider is empty
Type
"yes" | "no" | "unknown"
Example

Check if empty

let isEmpty = dataprovider.isEmpty();
console.log('DataProvider is empty: ' + isEmpty);

removeEventListener(eventType: string, listener: EventListener): void

Remove a listener previously registered with addEventListener.
Parameters:
Name Type Description
eventType string The event type that the listener was registered for.
listener EventListener The callback function that was registered.

setSection(section: IndexerModel.Section): Promise<oj.IndexerModel.Section>

Make a section current in the Indexer.
Parameters:
Name Type Description
section string | Object the current section
Returns:
a Promise which when resolved will return the section that the associated ListView actually scrolls to. For example, the implementation could choose to scroll to the next available section in ListView if no data exists for the current section section.
Type
Promise.<string> | Promise.<Object>

Type Definitions

Options<D>

Properties:
Name Type Argument Description
groupingAttribute string <optional>
 the attribute of the data where grouping is based on, mandatory if no groupingStrategy is specified.
groupingStrategy (data: D)=> IndexerModel.Section <optional>
 a callback function that takes a data and returns the section that the data belongs to. If no groupingStrategy is specified, then the default grouping strategy based on the first letter of the data is used.
implicitSort Array.<SortCriterion.<D>> <optional>
 array of SortCriterion used to specify sort information when the data loaded into the DataProvider is already sorted.
keyAttributes string | Array.<string> <optional>
 the field of the data that uniquely identifies the data. Can be a string denoting a single key attribute or an array of strings for multiple key attributes. If not specified, then one will be created.
sectionChangeHandler ((section: IndexerModel.Section)=> Promise<oj.IndexerModel.Section>) <optional>
 a callback function that handles when a section becomes current (user clicks on the section in the Indexer). the function takes the section that is going to become current and must return a Promise which when resolve returns the section that actually becomes current.
sections string | Array.<string> <optional>
 the set of sections to use with the Indexer. If not specified, then the sections are derived from the alphabet of the current locale.
sortComparators ArrayDataProvider.SortComparators<D> <optional>
 a comparator function that is used to sort data within a section.