igniteui-webcomponents-datasources
Version:
Reference custom data providers for the Ignite UI Web Components data source.
1,261 lines (1,249 loc) • 143 kB
JavaScript
/*!
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE: you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { fromEnum, XName, DataSourceSchemaPropertyType, XDocument, XmlNodeType, typeCast, XElement, ODataDataSourceSchema, XNamespace, AsyncVirtualDataSourceProviderTaskDataHolder, markType, AsyncVirtualDataSourceProviderWorker, SortDescriptionCollection, ListSortDirection, DataSourceSummaryScope, stringIsNullOrEmpty, Convert, DefaultSectionInformation, DataSourceSummaryOperand, DefaultSummaryResult, AsyncVirtualDataTask, AsyncDataSourcePageTaskHolder, ODataDataSourceFilterExpressionVisitor, TransactionType, AsyncVirtualDataSourceDataProviderWorkerSettings, Base, FilterExpressionCollection, SummaryDescriptionCollection, DataSourcePageRequestPriority, runOn, DataSourceDataProviderSchemaChangedEventArgs, stringContains, IDataSourceVirtualDataProvider_$type, VirtualDataSource, LocalDataSource, DefaultDataSourceSchema } from 'igniteui-webcomponents-core';
class EntityProperty {
constructor(name, schemaType) {
this._name = null;
this._isNullable = false;
this._type = null;
this.name = name;
this.type = schemaType;
}
get name() {
return this._name;
}
set name(value) {
this._name = value;
}
get isNullable() {
return this._isNullable;
}
set isNullable(value) {
this._isNullable = value;
}
get type() {
return this._type;
}
set type(value) {
this._type = value;
}
}
function toArray(en) {
return Array.from(fromEnum(en));
}
function first(iter) {
for (let v of iter) {
return v;
}
throw new Error("Iterable contained no elements, expected at least one");
}
class LinkedList {
get first() {
return this._first;
}
get last() {
return this._last;
}
addFirst(item) {
if (this._first == null) {
this._first = new LinkedListNode(item);
this._last = this._first;
}
else {
var oldFirst = this._first;
this._first = new LinkedListNode(item);
this._first.next = oldFirst;
oldFirst.prev = this._first;
}
}
addLast(item) {
if (this._last == null) {
this._first = new LinkedListNode(item);
this._last = this._first;
}
else {
var oldLast = this._last;
this._last = new LinkedListNode(item);
this._last.prev = oldLast;
oldLast.next = this._last;
}
}
removeFirst() {
this.remove(this.first);
}
clear() {
this._first = null;
this._last = null;
}
contains(value) {
let curr = this.first;
while (curr != null) {
if (curr.value === value) {
return true;
}
curr = curr.next;
}
return false;
}
removeValue(value) {
let curr = this.first;
while (curr != null) {
if (curr.value === value) {
this.remove(curr);
return;
}
curr = curr.next;
}
}
remove(node) {
if (this._first == node) {
this._first = node.next;
if (node.next != null) {
node.next.prev = null;
}
}
if (this._last == node) {
this._last = node.prev;
if (node.prev != null) {
node.prev.next = null;
}
}
if (node.prev != null) {
node.prev.next = node.next;
}
if (node.next != null) {
node.next.prev = node.prev;
}
node.next = null;
node.prev = null;
}
}
class LinkedListNode {
get value() {
return this._value;
}
set value(value) {
this._value = value;
}
get prev() {
return this._prev;
}
set prev(value) {
this._prev = value;
}
get next() {
return this._next;
}
set next(value) {
this._next = value;
}
constructor(item) {
if (item !== undefined) {
this.value = item;
}
}
}
class Entity {
constructor(name, entityNode) {
this._properties = null;
this._primaryKey = null;
this._name = null;
this.name = name;
this.loadProperties(entityNode);
this.loadPrimaryKey(entityNode);
}
get name() {
return this._name;
}
set name(value) {
this._name = value;
}
get properties() {
if (null == this._properties) {
this._properties = new Map();
}
return this._properties;
}
get primaryKey() {
if (null == this._primaryKey) {
this._primaryKey = [];
}
return this._primaryKey;
}
loadProperties(entityNode) {
let children = toArray(entityNode.elements());
let elementCount = children.length;
let nameAttr = XName.get("Name", "");
let typeAttr = XName.get("Type", "");
for (let i = 0; i < elementCount; i++) {
let node = children[i];
if (node.name.localName == "Property") {
let name = node.attribute(nameAttr).value;
let type = node.attribute(typeAttr).value;
this.properties.set(name, new EntityProperty(name, type));
}
}
;
}
loadPrimaryKey(entityNode) {
let children = toArray(entityNode.elements());
let elementCount = children.length;
let nameAttr = XName.get("Name", "");
for (let i = 0; i < elementCount; i++) {
let node = children[i];
if (node.name.localName == "Key") {
let subChildren = toArray(node.elements());
let keyNodeCOunt = subChildren.length;
for (let j = 0; j < keyNodeCOunt; j++) {
let keyNode = subChildren[j];
if (keyNode.name.localName == "PropertyRef") {
this.primaryKey.push(keyNode.attribute(nameAttr).value);
}
}
}
}
;
}
}
class EntitySet {
constructor(name, entityType) {
this._entityName = null;
this._entityNamespace = null;
this._entityType = null;
this._name = null;
this.name = name;
this.entityType = entityType;
if (entityType.indexOf(".") >= 0) {
let parts = entityType.split('.');
if (parts.length == 2) {
this.entityNamespace = parts[0];
this.entityName = parts[1];
}
else {
let i = entityType.lastIndexOf('.');
this.entityNamespace = entityType.substr(0, i);
this.entityName = entityType.substr(i + 1);
}
}
else {
this.entityNamespace = entityType;
this.entityName = entityType;
}
}
get entityName() {
return this._entityName;
}
set entityName(value) {
this._entityName = value;
}
get entityNamespace() {
return this._entityNamespace;
}
set entityNamespace(value) {
this._entityNamespace = value;
}
get entityType() {
return this._entityType;
}
set entityType(value) {
this._entityType = value;
}
get name() {
return this._name;
}
set name(value) {
this._name = value;
}
}
class ODataDataSourcePage {
constructor(sourceData_, schema, groupInformation, summaryInformation, pageIndex) {
this._actualData = null;
this._schema = null;
this._pageIndex = 0;
this._groupInformation = null;
this._summaryInformation = null;
if (sourceData_ == null) {
this._actualData = null;
}
else {
let count = (sourceData_.value.length);
this._actualData = [];
let dateProps = new Set();
for (let i = 0; i < schema.propertyNames.length; i++) {
if (schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeValue || schema.propertyTypes[i] == DataSourceSchemaPropertyType.DateTimeOffsetValue) {
dateProps.add(schema.propertyNames[i]);
}
}
let value_;
for (let i_ = 0; i_ < count; i_++) {
let currItem_ = sourceData_.value[i_];
let dict = new Map();
let properties = Array.from(Object.keys(currItem_));
let values = (properties.map((k) => currItem_[k]));
for (let i1 = 0; i1 < properties.length; i1++) {
value_ = values[i1];
if (dateProps.has(properties[i1])) {
value_ = new Date(value_);
}
dict.set(properties[i1], value_);
}
this._actualData[i_] = dict;
}
}
this._schema = schema;
this._groupInformation = groupInformation;
this._summaryInformation = summaryInformation;
this._pageIndex = pageIndex;
}
count() {
return this._actualData.length;
}
getItemAtIndex(index) {
return this._actualData[index];
}
getItemValueAtIndex(index, valueName) {
let item = this._actualData[index];
if (!item.has(valueName)) {
return null;
}
return item.get(valueName);
}
pageIndex() {
return this._pageIndex;
}
schema() {
return this._schema;
}
getGroupInformation() {
return this._groupInformation;
}
getSummaryInformation() {
return this._summaryInformation;
}
}
class Schema {
constructor(namespace, entityTypeElements, entitySetElements) {
this._entities = null;
this._entitySets = null;
this._namespace = null;
this.namespace = namespace;
this.loadEntities(entityTypeElements);
this.loadEntitySets(entitySetElements);
}
get entities() {
if (null == this._entities) {
this._entities = new Map();
}
return this._entities;
}
get entitySets() {
if (null == this._entitySets) {
this._entitySets = new Map();
}
return this._entitySets;
}
get namespace() {
return this._namespace;
}
set namespace(value) {
this._namespace = value;
}
loadEntities(entityTypeElements) {
let list = entityTypeElements;
let elementCount = list.length;
let name = XName.get("Name", "");
for (let i = 0; i < elementCount; i++) {
let node = list[i];
let entity = new Entity(node.attribute(name).value, node);
this.entities.set(entity.name, entity);
}
;
}
loadEntitySets(entitySetElements) {
let list = entitySetElements;
let elementCount = list.length;
let nameAttr = XName.get("Name", "");
let entityType = XName.get("EntityType", "");
for (let i = 0; i < elementCount; i++) {
let node = list[i];
let entitySet = new EntitySet(node.attribute(nameAttr).value, node.attribute(entityType).value);
this.entitySets.set(entitySet.name, entitySet);
}
;
}
}
let ODataSchemaProvider = /*@__PURE__*/ (() => {
class ODataSchemaProvider {
constructor(metadataDocument) {
this._entityTypeSchemaNamespace = null;
this._entitySetSchemaNamespace = null;
this._schema = null;
if (null == metadataDocument) {
return;
}
let xmlDoc = XDocument.parse(metadataDocument);
let schemaElements = toArray(first(fromEnum(first(fromEnum(xmlDoc.elements())).elements())).elements1(XName.get("Schema", ODataSchemaProvider.nS.namespaceName)));
if (null == schemaElements) {
return;
}
let entitySetElements = null;
let entityTypeElements = null;
let elementCount = schemaElements.length;
let entityContainer = XName.get("EntityContainer", ODataSchemaProvider.nS.namespaceName);
let entitySet = XName.get("EntitySet", ODataSchemaProvider.nS.namespaceName);
let namespaceAttribute = XName.get("Namespace", "");
let entityType = XName.get("EntityType", ODataSchemaProvider.nS.namespaceName);
for (let i = 0; i < elementCount; i++) {
let node = schemaElements[i];
if (node.nodeType != XmlNodeType.Element) {
continue;
}
let schemaElement = schemaElements[i];
if (null == entitySetElements) {
let nodes = toArray(schemaElement.elements1(entityContainer));
if (null != nodes && nodes.length > 0) {
entitySetElements = toArray((typeCast(XElement.$type, nodes[0])).elements1(entitySet));
if (null != entitySetElements) {
this._entitySetSchemaNamespace = schemaElement.attribute(namespaceAttribute).value;
}
}
}
if (null == entityTypeElements) {
entityTypeElements = toArray(schemaElement.elements1(entityType));
if (null != entityTypeElements) {
this._entityTypeSchemaNamespace = schemaElement.attribute(namespaceAttribute).value;
}
}
}
if (null == entitySetElements || null == entityTypeElements) {
return;
}
this.schema = new Schema(this._entityTypeSchemaNamespace, entityTypeElements, entitySetElements);
}
get schema() {
return this._schema;
}
set schema(value) {
this._schema = value;
}
getODataDataSourceSchema(entitySet) {
if (this.schema == null) {
return null;
}
let valueNames = [];
let valueTypes = [];
let primaryKey = [];
let es = this.schema.entitySets.get(entitySet);
if (null != es) {
let entity = this.schema.entities.get(es.entityName);
if (null != entity) {
for (let property of entity.properties.values()) {
valueNames.push(property.name);
if (property.type == "Edm.String") {
valueTypes.push(DataSourceSchemaPropertyType.StringValue);
}
else if (property.type == "Edm.Int16" || property.type == "Edm.Int32") {
valueTypes.push(DataSourceSchemaPropertyType.IntValue);
}
else if (property.type == "Edm.Double") {
valueTypes.push(DataSourceSchemaPropertyType.DoubleValue);
}
else if (property.type == "Edm.Single") {
valueTypes.push(DataSourceSchemaPropertyType.SingleValue);
}
else if (property.type == "Edm.Boolean") {
valueTypes.push(DataSourceSchemaPropertyType.BooleanValue);
}
else if (property.type == "Edm.Byte") {
valueTypes.push(DataSourceSchemaPropertyType.ShortValue);
}
else if (property.type == "Edm.DateTime" || property.type == "Edm.DateTimeOffset") {
valueTypes.push(DataSourceSchemaPropertyType.DateTimeValue);
}
else if (property.type == "Edm.Int64") {
valueTypes.push(DataSourceSchemaPropertyType.LongValue);
}
else if (property.type == "Edm.Decimal") {
valueTypes.push(DataSourceSchemaPropertyType.DecimalValue);
}
else if (property.type == "Edm.SByte") {
valueTypes.push(DataSourceSchemaPropertyType.ShortValue);
}
else {
valueTypes.push(DataSourceSchemaPropertyType.ObjectValue);
}
}
for (let k of entity.primaryKey) {
primaryKey.push(k);
}
}
}
return new ODataDataSourceSchema(valueNames, valueTypes, primaryKey);
}
}
ODataSchemaProvider.nS = /*@__PURE__*/ XNamespace.get("http://docs.oasis-open.org/odata/ns/edm");
return ODataSchemaProvider;
})();
let ODataVirtualDataSourceProviderTaskDataHolder = /*@__PURE__*/ (() => {
class ODataVirtualDataSourceProviderTaskDataHolder extends AsyncVirtualDataSourceProviderTaskDataHolder {
}
ODataVirtualDataSourceProviderTaskDataHolder.$t = /*@__PURE__*/ markType(ODataVirtualDataSourceProviderTaskDataHolder, 'ODataVirtualDataSourceProviderTaskDataHolder', AsyncVirtualDataSourceProviderTaskDataHolder.$type);
return ODataVirtualDataSourceProviderTaskDataHolder;
})();
let ODataVirtualDataSourceDataProviderWorker = /*@__PURE__*/ (() => {
class ODataVirtualDataSourceDataProviderWorker extends AsyncVirtualDataSourceProviderWorker {
get sortDescriptions() {
return this._sortDescriptions;
}
get filterExpressions() {
return this._filterExpressions;
}
get desiredProperties() {
return this._desiredPropeties;
}
initialize() {
super.initialize();
}
getTaskDataHolder() {
let holder = new ODataVirtualDataSourceProviderTaskDataHolder();
return holder;
}
getCompletedTaskData(holder, completed) {
super.getCompletedTaskData(holder, completed);
}
removeCompletedTaskData(holder, completed) {
super.removeCompletedTaskData(holder, completed);
}
getTasksData(holder) {
super.getTasksData(holder);
}
*iter(coll) {
for (let i = 0; i < coll.size(); i++) {
yield coll.get(i);
}
}
*iterFilter(coll) {
for (let i = 0; i < coll.size(); i++) {
yield coll.get(i);
}
}
*iterSummaries(summaries) {
for (let i = 0; i < summaries.size(); i++) {
yield summaries.get(i);
}
}
constructor(settings) {
super(settings);
this._baseUri = null;
this._entitySet = null;
this._sortDescriptions = null;
this._groupDescriptions = null;
this._filterExpressions = null;
this._summaryDescriptions = null;
this._desiredPropeties = null;
this._schemaIncludedProperties = null;
this._enableJsonp = true;
this._isAggregationSupported = false;
this._groupInformation = null;
this._summaryInformation = null;
this._filterString = null;
this._selectedString = null;
this.doWork = this.doWork.bind(this);
this._baseUri = settings.baseUri;
this._entitySet = settings.entitySet;
this._sortDescriptions = settings.sortDescriptions;
this._groupDescriptions = settings.groupDescriptions;
if (this._groupDescriptions != null && this._groupDescriptions.size() > 0) {
this._sortDescriptions = new SortDescriptionCollection();
for (let sd of this.iter(settings.sortDescriptions)) {
this._sortDescriptions.add(sd);
}
for (let i = 0; i < this._groupDescriptions.size(); i++) {
this._sortDescriptions.insert(i, this._groupDescriptions.get(i));
}
}
this._filterExpressions = settings.filterExpressions;
this._desiredPropeties = settings.propertiesRequested;
if (settings.schemaIncludedProperties != null) {
this._schemaIncludedProperties = new Set();
for (let i = 0; i < settings.schemaIncludedProperties.length; i++) {
this._schemaIncludedProperties.add(settings.schemaIncludedProperties[i]);
}
}
this._summaryDescriptions = settings.summaryDescriptions;
this._summaryScope = settings.summaryScope;
this._enableJsonp = settings.enableJsonp;
this._isAggregationSupported = settings.isAggregationSupported;
window.setTimeout(this.doWork, 100);
}
processCompletedTask(completedTask, currentDelay, pageIndex, taskDataHolder) {
let h = taskDataHolder;
let schema = null;
let result = null;
let schemaFetchCount = -1;
let task = completedTask.task;
try {
if (task.hasErrors) {
this.retryIndex(pageIndex, currentDelay);
return;
}
if (pageIndex == ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
result = task.result;
schemaFetchCount = (result['@odata.count']);
}
else {
result = task.result;
}
}
catch (e) {
this.retryIndex(pageIndex, currentDelay);
return;
}
if (schemaFetchCount >= 0) {
this.actualCount = schemaFetchCount;
}
else {
this.actualCount = (result['@odata.count']);
}
schema = this.actualSchema;
if (schema == null) {
let requests = 0;
this.resolveSchema((s) => {
// resolveSchema success callback
this.actualSchema = s;
if (this._isAggregationSupported && (this._groupDescriptions.size() !== 0 || this._summaryDescriptions.size() !== 0)) {
if (this._groupDescriptions.size() > 0) {
requests++;
this.resolveGroupInformation((g) => {
// group info success
requests--;
if (requests === 0) {
this.finishProcessingCompletedTask(task, pageIndex, s, result);
}
}, () => {
// group info failure
this.retryIndex(pageIndex, currentDelay);
return;
});
}
if (this._summaryDescriptions.size() > 0) {
requests++;
this.resolveSummaryInformation((g) => {
// summary info success
requests--;
if (requests === 0) {
this.finishProcessingCompletedTask(task, pageIndex, s, result);
}
}, () => {
// summary info failure
this.retryIndex(pageIndex, currentDelay);
return;
});
}
}
else {
this.finishProcessingCompletedTask(task, pageIndex, s, result);
}
}, () => {
// resolveSchema failure callback
this.retryIndex(pageIndex, currentDelay);
return;
});
return;
}
this.finishProcessingCompletedTask(task, pageIndex, schema, result);
}
finishProcessingCompletedTask(task, pageIndex, schema, result) {
let executionContext;
let pageLoaded;
let groupInformation;
let summaryInformation;
this.actualSchema = schema;
executionContext = this.executionContext;
groupInformation = this._groupInformation;
summaryInformation = this._summaryInformation;
pageLoaded = this.pageLoaded;
let page = null;
if (result != null) {
page = new ODataDataSourcePage(result, schema, groupInformation, summaryInformation, pageIndex);
if (!this.isLastPage(pageIndex) && page.count() > 0 && !this.populatedActualPageSize) {
this.populatedActualPageSize = true;
this.actualPageSize = page.count();
}
}
else {
page = new ODataDataSourcePage(null, schema, groupInformation, summaryInformation, pageIndex);
}
if (this.pageLoaded != null) {
if (this.executionContext != null) {
if (executionContext == null || pageLoaded == null) {
this.shutdown();
return;
}
executionContext.execute(() => pageLoaded(page, this.actualCount, this.actualPageSize));
}
else {
if (pageLoaded == null) {
this.shutdown();
return;
}
pageLoaded(page, this.actualCount, this.actualPageSize);
}
}
}
resolveGroupInformation(finishAction, failureAction) {
if (this._groupInformation != null) {
finishAction(this._groupInformation);
return;
}
let orderBy = "";
let groupBy = "";
let filter = null;
let summary = "";
if (this._groupDescriptions == null || this._groupDescriptions.size() == 0) {
finishAction(null);
return;
}
filter = this._filterString;
this.updateFilterString();
if (this._groupDescriptions != null) {
let first1 = true;
for (let group of this.iter(this._groupDescriptions)) {
if (first1) {
first1 = false;
}
else {
orderBy += ", ";
groupBy += ", ";
}
groupBy += group.propertyName;
if (group.direction === ListSortDirection.Descending) {
orderBy += group.propertyName + " desc";
}
else {
orderBy += group.propertyName + " asc";
}
}
}
if (this._summaryScope === DataSourceSummaryScope.Both || this._summaryScope === DataSourceSummaryScope.Groups) {
let summaryParameters = this.getSummaryQueryParameters(true);
if (!stringIsNullOrEmpty(summaryParameters)) {
summary = ", " + summaryParameters;
}
}
let commandText = this._entitySet + "?$orderby=" + orderBy + "&$apply=";
if (!stringIsNullOrEmpty(filter)) {
commandText += "filter(" + filter + ")/";
}
commandText += "groupby((" + groupBy + "), aggregate($count as $__count" + summary + "))";
try {
let groupInformation = [];
let success_ = (data, response) => this.groupSuccess(data, response, finishAction, failureAction, groupInformation);
let failure_ = (err) => this.groupError(err, finishAction, failureAction, groupInformation);
let run_ = null;
var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
var request = {
requestUri: this._baseUri + "/" + commandText,
enableJsonpCallback: this._enableJsonp,
method: 'GET',
headers: headers,
data: null
};
run_ = function () {
odatajs.oData.request(request, success_, failure_);
};
run_();
}
catch (e) {
failureAction();
}
}
groupError(err, finishAction, failureAction, groupInformation) {
this._groupInformation = null;
}
groupSuccess(data, response, finishAction, failureAction, groupInformation) {
let groupNames = [];
for (let group of this.iter(this._groupDescriptions)) {
groupNames.push(group.propertyName);
}
let groupNamesArray = groupNames;
if (data && data.value && data.value.length > 0) {
let currentIndex = 0;
for (let i = 0; i < data.value.length; i++) {
this.addGroup(groupInformation, groupNames, groupNames, currentIndex, data.value[i]);
}
}
this._groupInformation = groupInformation;
finishAction(this._groupInformation);
}
addGroup(groupInformation, groupNames, groupNamesArray, currentIndex, group) {
let groupValues = [];
for (let name of groupNames) {
if (group[name]) {
groupValues.push(group[name]);
}
}
let groupCount = 0;
if (group["$__count"]) {
groupCount = Convert.toInt321(group["$__count"]);
}
let summaryResults = null;
if (this._summaryScope == DataSourceSummaryScope.Both || this._summaryScope == DataSourceSummaryScope.Groups) {
summaryResults = this.createSummaryResults(group);
}
let groupInfo = new DefaultSectionInformation(currentIndex, currentIndex + (groupCount - 1), groupNamesArray, groupValues, summaryResults);
groupInformation.push(groupInfo);
}
resolveSummaryInformation(finishAction, failureAction) {
if (this._summaryInformation != null) {
finishAction(this._summaryInformation);
return;
}
let filter = null;
let summary = null;
if (this._summaryDescriptions == null ||
this._summaryDescriptions.size() == 0 ||
this._summaryScope == DataSourceSummaryScope.Groups ||
this._summaryScope == DataSourceSummaryScope.None) {
finishAction(null);
return;
}
filter = this._filterString;
this.updateFilterString();
summary = this.getSummaryQueryParameters(false);
let commandText = this._entitySet + "?$apply=";
if (!stringIsNullOrEmpty(filter)) {
commandText += "filter(" + filter + ")/";
}
commandText += "aggregate(" + summary + ")";
try {
let summaryInformation = [];
let success_ = (data, response) => this.summarySuccess(data, response, finishAction, failureAction, summaryInformation);
let failure_ = (err) => this.summaryError(err, finishAction, failureAction, summaryInformation);
let run_ = null;
var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
var request = {
requestUri: this._baseUri + "/" + commandText,
enableJsonpCallback: this._enableJsonp,
method: 'GET',
headers: headers,
data: null
};
run_ = function () {
odatajs.oData.request(request, success_, failure_);
};
run_();
}
catch (e) {
failureAction();
}
}
summarySuccess(data, response, finishAction, failureAction, summaryInformation) {
if (data && data.value && data.value.length > 0) {
summaryInformation = this.createSummaryResults(data.value[0]);
}
this._summaryInformation = summaryInformation;
finishAction(this._summaryInformation);
}
summaryError(err, finishAction, failureAction, summaryInformation) {
this._summaryInformation = null;
}
getSummaryQueryParameters(ignoreCount) {
let result = "";
if (this._summaryDescriptions != null) {
let first = true;
let countExists = false;
for (let summary of this.iterSummaries(this._summaryDescriptions)) {
if (summary.operand == DataSourceSummaryOperand.Count && (ignoreCount || countExists)) {
continue;
}
if (!first) {
result += ", ";
}
switch (summary.operand) {
case DataSourceSummaryOperand.Average:
result += summary.propertyName + " with average as " + summary.propertyName + "Average";
break;
case DataSourceSummaryOperand.Min:
result += summary.propertyName + " with min as " + summary.propertyName + "Min";
break;
case DataSourceSummaryOperand.Max:
result += summary.propertyName + " with max as " + summary.propertyName + "Max";
break;
case DataSourceSummaryOperand.Sum:
result += summary.propertyName + " with sum as " + summary.propertyName + "Sum";
break;
case DataSourceSummaryOperand.Count:
result += "$count as $__count";
countExists = true;
break;
}
first = false;
}
}
return result;
}
createSummaryResults(data) {
let summaryResults = [];
for (let summary of this.iterSummaries(this._summaryDescriptions)) {
let summaryName = summary.propertyName;
switch (summary.operand) {
case DataSourceSummaryOperand.Average:
summaryName += "Average";
break;
case DataSourceSummaryOperand.Min:
summaryName += "Min";
break;
case DataSourceSummaryOperand.Max:
summaryName += "Max";
break;
case DataSourceSummaryOperand.Sum:
summaryName += "Sum";
break;
case DataSourceSummaryOperand.Count:
summaryName = "$__count";
break;
}
let summaryValue = null;
if (data && data[summaryName]) {
summaryValue = data[summaryName];
}
let summaryResult = new DefaultSummaryResult(summary.propertyName, summary.operand, summaryValue);
summaryResults.push(summaryResult);
}
return summaryResults;
}
resolveSchema(finishAction, failureAction) {
let success_ = (res) => {
let sp = new ODataSchemaProvider(res);
let schema = sp.getODataDataSourceSchema(this._entitySet);
if (this._schemaIncludedProperties != null) {
let propertyNames = [];
let propertyTypes = [];
for (let i = 0; i < schema.propertyNames.length; i++) {
if (!this._schemaIncludedProperties.has(schema.propertyNames[i])) {
continue;
}
propertyNames.push(schema.propertyNames[i]);
propertyTypes.push(schema.propertyTypes[i]);
}
schema = new ODataDataSourceSchema(propertyNames, propertyTypes, schema.primaryKey);
}
finishAction(schema);
};
let failure_ = () => failureAction();
let baseUri_ = this._baseUri;
var request = new XMLHttpRequest();
request.onreadystatechange = function () {
if (request.readyState === 4) {
if (request.status === 200) {
success_(request.responseText);
}
else {
failure_();
}
}
};
request.open('Get', baseUri_ + '/$metadata');
request.send();
;
}
makeTaskForRequest(request, retryDelay) {
let actualPageSize = 0;
let sortDescriptions = null;
actualPageSize = this.actualPageSize;
sortDescriptions = this.sortDescriptions;
let requestUrl = this._baseUri;
requestUrl += "/" + this._entitySet;
let queryStarted = false;
this.updateFilterString();
if (this._filterString != null) {
if (!queryStarted) {
queryStarted = true;
requestUrl += "?";
}
else {
requestUrl += "&";
}
requestUrl += "$filter=" + this._filterString;
}
if (this.sortDescriptions != null) {
let sortString = null;
for (let sort of this.iter(this.sortDescriptions)) {
if (sortString == null) {
sortString = "";
}
else {
sortString += ", ";
}
if (sort.direction == ListSortDirection.Descending) {
sortString += sort.propertyName + " desc";
}
else {
sortString += sort.propertyName;
}
}
if (sortString != null) {
if (!queryStarted) {
queryStarted = true;
requestUrl += "?";
}
else {
requestUrl += "&";
}
requestUrl += "$orderby=" + sortString;
}
}
if (this.desiredProperties != null && this.desiredProperties.length > 0) {
let selectString = "";
let first = true;
let $t = this.desiredProperties;
for (let i = 0; i < $t.length; i++) {
let select = $t[i];
if (first) {
first = false;
}
else {
selectString += ", ";
}
selectString += select;
}
if (!queryStarted) {
queryStarted = true;
requestUrl += "?";
}
else {
requestUrl += "&";
}
requestUrl += "$select=" + selectString;
}
let task = new AsyncVirtualDataTask();
if (request.index == ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex) {
this.executeRequest(requestUrl, queryStarted, 0, actualPageSize, task);
}
else {
this.executeRequest(requestUrl, queryStarted, request.index * actualPageSize, actualPageSize, task);
}
request.taskHolder = new AsyncDataSourcePageTaskHolder();
request.taskHolder.task = task;
this.tasks.add(request);
}
updateFilterString() {
if (this.filterExpressions != null && this.filterExpressions.size() > 0 && this._filterString == null) {
let sb = "";
let first = true;
for (let expr of this.iterFilter(this.filterExpressions)) {
if (first) {
first = false;
}
else {
sb += " AND ";
}
let visitor = new ODataDataSourceFilterExpressionVisitor(0);
visitor.visit(expr);
let txt = visitor.toString();
if (this.filterExpressions.size() > 1) {
txt = "(" + txt + ")";
}
sb += (txt);
}
this._filterString = sb;
}
}
executeRequest(requestUrl, queryStarted, skip, top, task) {
if (!queryStarted) {
queryStarted = true;
requestUrl += "?";
}
else {
requestUrl += "&";
}
requestUrl += "$skip=" + skip + "&$top=" + top + "&$count=true";
let requestUrl_ = requestUrl;
let self_ = this;
let success_ = (data, response) => this.success(task, data, response);
let failure_ = (err) => this.error(task, err);
let run_ = null;
var headers = { 'Content-Type': 'application/json', Accept: 'application/json' };
var request = {
requestUri: requestUrl_,
enableJsonpCallback: this._enableJsonp,
method: 'GET',
headers: headers,
data: null
};
run_ = function () {
odatajs.oData.request(request, success_, failure_);
};
task.run = run_;
}
success(t, data, response) {
t.result = data;
t.isCompleted = true;
}
error(t, result) {
t.isCompleted = true;
t.hasErrors = true;
}
createBatchRequest(changes) {
const requests = [];
for (let i = 0; i < changes.length; i++) {
let c = changes[i];
const headers = { "Content-Type": "application/json", "odata-version": "4.0" };
if (c.transactionType === TransactionType.Add) {
requests.push({
method: "POST",
id: `r${i}`,
atomicityGroup: "g1",
url: `${this._baseUri}/${this._entitySet}`,
headers: headers,
body: c.value,
});
}
else if (c.transactionType === TransactionType.Update) {
if (c.version) {
headers["If-Match"] = c.version;
}
requests.push({
method: "PATCH",
id: `r${i}`,
atomicityGroup: "g1",
url: `${this._baseUri}/${this.getRequestUriWithKey(c.id)}`,
headers: headers,
body: c.value,
});
}
else if (c.transactionType === TransactionType.Delete) {
if (c.version) {
headers["If-Match"] = c.version;
}
requests.push({
method: "DELETE",
id: `r${i}`,
atomicityGroup: "g1",
url: `${this._baseUri}/${this.getRequestUriWithKey(c.id)}`,
headers: headers,
});
}
}
let request = {
requestUri: `${this._baseUri}/$batch`,
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ requests: requests })
};
let self = this;
odatajs.oData.request(request, function (data) {
if (data && data.responses) {
if (data.responses.length > 0) {
let success = true;
let messages = [];
for (let i = 0; i < data.responses.length; i++) {
if (data.responses[i].status !== 200 &&
data.responses[i].status !== 204) {
success = false;
let failedRequest = requests.filter(r => r.id == data.responses[i].id)[0];
if (failedRequest) {
let msg = `${failedRequest.method} request failed with code ${data.responses[i].status}`;
messages.push(msg);
console.error(msg);
}
break;
}
}
if (success) {
self.batchCompleted(true, true, null);
}
else {
self.batchCompleted(false, true, messages);
}
}
else {
self.batchCompleted(false, true, null);
}
}
}, function (error) {
const messages = [];
if (error && error.message) {
messages.push(error.message);
}
self.batchCompleted(false, true, messages);
});
}
getRequestUriWithKey(key) {
let result = "";
const keys = Object.keys(key);
for (let i = 0; i < keys.length; i++) {
if (i > 0) {
result += ",";
}
result += `${keys[i]}=${key[keys[i]]}`;
}
return `${this._entitySet}(${result})`;
}
}
ODataVirtualDataSourceDataProviderWorker.schemaRequestIndex = -1;
return ODataVirtualDataSourceDataProviderWorker;
})();
let ODataVirtualDataSourceDataProviderWorkerSettings = /*@__PURE__*/ (() => {
class ODataVirtualDataSourceDataProviderWorkerSettings extends AsyncVirtualDataSourceDataProviderWorkerSettings {
constructor() {
super(...arguments);
this._baseUri = null;
this._entitySet = null;
this._sortDescriptions = null;
this._filterExpressions = null;
this._propertiesRequested = null;
this._schemaIncludedProperties = null;
this._groupDescriptions = null;
this._summaryDescriptions = null;
}
get baseUri() {
return this._baseUri;
}
set baseUri(value) {
this._baseUri = value;
}
get entitySet() {
return this._entitySet;
}
set entitySet(value) {
this._entitySet = value;
}
get sortDescriptions() {
return this._sortDescriptions;
}
set sortDescriptions(value) {
this._sortDescriptions = value;
}
get filterExpressions() {
return this._filterExpressions;
}
set filterExpressions(value) {
this._filterExpressions = value;
}
get propertiesRequested() {
return this._propertiesRequested;
}
set propertiesRequested(value) {
this._propertiesRequested = value;
}
get schemaIncludedProperties() {
return this._schemaIncludedProperties;
}
set schemaIncludedProperties(value) {
this._schemaIncludedProperties = value;
}
get groupDescriptions() {
return this._groupDescriptions;
}
set groupDescriptions(value) {
this._groupDescriptions = value;
}
get summaryDescriptions() {
return this._summaryDescriptions;
}