igniteui-webcomponents-datasources 7.1.1-beta.2 → 7.1.1-beta.4

package/esm2022/lib/ODataVirtualDataSourceDataProviderWorker.js

@@ -0,0 +1,710 @@
+import { AsyncVirtualDataSourceProviderWorker } from "igniteui-webcomponents-core";
+import { SortDescriptionCollection } from "igniteui-webcomponents-core";
+import { ODataVirtualDataSourceProviderTaskDataHolder } from "./ODataVirtualDataSourceProviderTaskDataHolder";
+import { AsyncDataSourcePageTaskHolder } from "igniteui-webcomponents-core";
+import { AsyncVirtualDataTask } from "igniteui-webcomponents-core";
+import { ODataDataSourcePage } from "./ODataDataSourcePage";
+import { DefaultSectionInformation } from "igniteui-webcomponents-core";
+import { Convert } from "igniteui-webcomponents-core";
+import { ODataSchemaProvider } from "./ODataSchemaProvider";
+import { ODataDataSourceFilterExpressionVisitor } from "igniteui-webcomponents-core";
+import { ListSortDirection } from "igniteui-webcomponents-core";
+import { stringIsNullOrEmpty } from "igniteui-webcomponents-core";
+import { DataSourceSummaryOperand } from "igniteui-webcomponents-core";
+import { DataSourceSummaryScope } from "igniteui-webcomponents-core";
+import { DefaultSummaryResult } from "igniteui-webcomponents-core";
+import { TransactionType } from "igniteui-webcomponents-core";
+import { ODataDataSourceSchema } from "igniteui-webcomponents-core";
+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();
+        ;
+    }
+    static { this.schemaRequestIndex = -1; }
+    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})`;
+    }
+}
+export { ODataVirtualDataSourceDataProviderWorker };