Final Class: ListDataProviderView

Oracle® JavaScript Extension Toolkit (JET)
9.0.0

F24343-01

Signature:

final class ListDataProviderView<K, D, Kin, Din> implements DataProvider<K, D>

QuickNav

Fields

ListDataProviderView

Version:
  • 9.0.0
Since:
  • 4.1.0
Module:
  • ojlistdataproviderview

Module usage

See JET Module Loading for an overview of module usage within JET.

Javascript Import Format
define(['ojs/ojlistdataproviderview'], function(ListDataProviderView) {
 // Application should call API on ListDataProviderView 
})
Typescript Import Format
//This class is exported directly as module. To import it
import ListDataProviderView= require("ojs/ojlistdataproviderview");

Generic Parameters
ParameterDescription
KType of output key
DType of output data
KinType of input key
DinType of input data

JET In Typescript

A detailed description of working with JET elements and classes in your typescript project can be found at: JET Typescript Usage.

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.

Description

Provides list based optimizations for DataProvider and adds some support for providing state for certain operations. e.g supports DataProvider#fetchFirst starting at arbitrary key or index offset, sortCriteria, and field mapping. Please see the select demos for examples of DataMapping Select

Constructor

new ListDataProviderView(dataProvider, options)

Parameters:
Name Type Argument Description
dataProvider DataProvider.<K, D> the DataProvider.
options Object <optional>
Options for the ListDataProviderView
Properties
Name Type Argument Description
from Kin <optional>
key to start fetching from. This will be applied first before offset is applied.
offset number <optional>
offset to start fetching from.
sortCriteria Array.<SortCriterion.<D>> <optional>
SortCriterion to apply to the data.
dataMapping DataMapping.<K, D, Kin, Din> <optional>
mapping to apply to the data.
attributes Array<string | FetchAttribute> <optional>
fetch attributes to apply
filterCriterion DataFilter.Filter.<D> <optional>
filter criterion to apply. If the DataProvider does not support filtering then ListDataProviderView will do local filtering of the data.

Fields

(nullable) attributes :Array.<(string|FetchAttribute)>

Optional fetch attributes to apply. Used to set on the ListDataProviderView instance instead of through the constructor.
Since:
  • 4.1.0
Example

set the attribute filter for fetching

dataprovider.attributes = ['!lastName', '@default']; // all attributes except lastName

(nullable) dataMapping :DataMapping.<K, D, Kin, Din>

Optional dataMapping to apply. Used to set on the ListDataProviderView instance instead of through the constructor.
Since:
  • 4.1.0
Example

set the data mapping for fetching

dataprovider.dataMapping = function (item) {
  let data = item.data;
  let mappedItem = {};
  mappedItem.data = {};
  mappedItem.data.label = data.name;
  mappedItem.data.value = data.id;
  mappedItem.metadata = { key: data.id };
  return mappedItem;
};

(nullable) filterCriterion :DataFilter.Filter.<D>

Optional filter criterion to apply. Used to set on the ListDataProviderView instance instead of through the constructor.
Since:
  • 7.0.0
Example

set the filter criterion for fetching

let filterDef = {op: '$or', criteria: [{op: '$eq', value: {name: 'Bob'}}, {op: '$gt', value: {level: 'Low'}}]};
dataprovider.filterCriterion = FilterFactory.getFilter(filterDef); // create a standard filter using the filterFactory.

(nullable) from :Kin

Optional key to start fetching from. Used to set on the ListDataProviderView instance instead of through the constructor.
Since:
  • 4.1.0
Example

set the key to start fetching from

dataprovider.from = '1234';

(nullable) offset :number

Optional offset to start fetching from. Used to set on the ListDataProviderView instance instead of through the constructor.. Should be greater than or equal to zero. If a negative offset is used then it will be treated as zero.
Since:
  • 4.1.0
Example

set the offset to start fetching from

dataprovider.offset = 5;

(nullable) sortCriteria :Array.<SortCriterion.<D>>

Optional sortCriteria to apply. Used to set on the ListDataProviderView instance instead of through the constructor.
Since:
  • 4.1.0
Example

set the sortCriteria for fetching

dataprovider.sortCriteria = [{attribute: 'DepartmentName', direction: 'ascending'}];

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. The resulting key map will only contain keys which were actually found.
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. The resulting key map will only contain keys which were actually found.
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 asyncIterator which can be used to fetch a block of data.
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;
});
// true or false for done
let done = result.done;

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
  ...

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.