@aurigma/design-atoms/Services/MultiCallRequest.js

Design Atoms is a part of Customer's Canvas SDK which allows for manipulating individual design elements through your code.

export class MultiCallRequest {
    constructor(_service, _imageLoaderService) {
        this._service = _service;
        this._imageLoaderService = _imageLoaderService;
        this._multiCallInProgress = false;
        this._multiCallItems = null;
        this._multiCallCallbacks = null;
        this._endMultiCallPromiseFuncs = null;
        this._multiCallInProgress = false;
        this._multiCallItems = [];
        this._multiCallCallbacks = [];
        this._multiCallCounter = 0;
        this._endMultiCallPromiseFuncs = [];
    }
    increaseCounter() {
        this._multiCallCounter++;
    }
    decreaseCounter() {
        this._multiCallCounter--;
        return this._multiCallCounter;
    }
    enqueueEndMultiCall() {
        return new Promise((resolve, reject) => this._endMultiCallPromiseFuncs.push([resolve, reject]));
    }
    get multiCallStarted() {
        return this._multiCallCounter > 0;
    }
    beginMultiCall() {
        this.increaseCounter();
    }
    endMultiCall(requestImage = true) {
        if (this.decreaseCounter() > 0) {
            return this.enqueueEndMultiCall();
        }
        if (this._multiCallItems == null || this._multiCallItems.length < 1) {
            this._onMultiCallFinally();
            return Promise.resolve(false);
        }
        const items = this._multiCallItems;
        const callbacks = this._multiCallCallbacks;
        const promiseFuncs = this._endMultiCallPromiseFuncs;
        this._multiCallItems = [];
        this._multiCallCallbacks = [];
        this._endMultiCallPromiseFuncs = [];
        return this._updateByMultiCall(items, callbacks, promiseFuncs, requestImage);
    }
    queueForMultiCall(data, success, failure) {
        if (this._multiCallInProgress)
            return false;
        this._multiCallItems.push(data);
        this._multiCallCallbacks.push([success, failure]);
        return true;
    }
    _updateByMultiCall(items, callbacks, promiseFuncs, requestImage = true) {
        this._multiCallInProgress = true;
        return new Promise((resolve, reject) => {
            const filteredItems = this._filter(items, callbacks);
            this._updateByMultiCallRequest({ items: filteredItems.items }, response => this._onMultiCallDone(response, filteredItems.callbacks, resolve, promiseFuncs, requestImage), (error, userContext, methodName) => this._onMultiCallFailed(error, userContext, methodName, items, callbacks, reject, promiseFuncs));
        });
    }
    _filter(items, callbacks) {
        items = items.reverse();
        callbacks = callbacks.reverse();
        const uniqIdsIndexes = [];
        const itemDataIds = [];
        items = items.filter((d, index) => {
            if (d.itemData == null || itemDataIds.includes(d.itemData.id))
                return false;
            itemDataIds.push(d.itemData.id);
            uniqIdsIndexes.push(index);
            return true;
        });
        return {
            items: items,
            callbacks: uniqIdsIndexes.map(i => callbacks[i])
        };
    }
    _onMultiCallDone(data, callbacks, updateByMultiCallResolve, promiseFuncs, requestImage = true) {
        try {
            if (requestImage)
                this._imageLoaderService.loadCombinedImage(data.combinedImageDescription);
            const resultItems = data.items;
            for (let i = 0; i < resultItems.length; i++)
                this._processItemResult(resultItems[i], callbacks[i]);
        }
        finally {
            this._onMultiCallFinally();
            updateByMultiCallResolve(true);
            if (promiseFuncs != null)
                promiseFuncs.forEach(x => x[0](true));
        }
    }
    _processItemResult(resultItem, callbacks) {
        try {
            const [successCallback, failedCallback] = callbacks;
            if (resultItem.error)
                failedCallback({ errorMessage: resultItem.errorMessage });
            else {
                successCallback(resultItem.result);
            }
        }
        catch (e) {
            console.error("Error while processing ItemHandlers service response", e);
        }
    }
    _onMultiCallFailed(error, userContext, methodName, items, callbacks, updateByMultiCallReject, promiseFuncs) {
        try {
            for (let i = 0; i < callbacks.length; i++)
                if (callbacks[i][1])
                    callbacks[i][1](error, userContext, methodName);
        }
        finally {
            this._onMultiCallFinally();
            updateByMultiCallReject();
            if (promiseFuncs != null)
                promiseFuncs.forEach(x => x[1]());
        }
    }
    _updateByMultiCallRequest(data, resolve, failure) {
        this._service.sendRequest("UpdateByMultiCallRequest", data, resolve, failure);
    }
    _onMultiCallFinally() {
        this._multiCallInProgress = false;
        this._multiCallItems = [];
        this._multiCallCallbacks = [];
    }
}
//# sourceMappingURL=MultiCallRequest.js.map