@wavemaker/app-ng-runtime 11.8.0-next.141156 → 11.8.0-next.141663

package/components/base/esm2022/utils/data-utils.mjs

@@ -0,0 +1,580 @@
+import { DataSource, debounce, processFilterExpBindNode } from '@wm/core';
+import { FormWidgetType, isDefined, MatchMode } from '@wm/core';
+import { isDataSetWidget } from './widget-utils';
+const noop = () => { };
+export var Live_Operations;
+(function (Live_Operations) {
+    Live_Operations["INSERT"] = "insert";
+    Live_Operations["UPDATE"] = "update";
+    Live_Operations["DELETE"] = "delete";
+    Live_Operations["READ"] = "read";
+})(Live_Operations || (Live_Operations = {}));
+export const ALLFIELDS = 'All Fields';
+export const LIVE_CONSTANTS = {
+    'EMPTY_KEY': 'EMPTY_NULL_FILTER',
+    'EMPTY_VALUE': 'No Value',
+    'LABEL_KEY': 'key',
+    'LABEL_VALUE': 'value',
+    'NULL_EMPTY': ['null', 'empty'],
+    'NULL': 'null',
+    'EMPTY': 'empty'
+};
+// Returns true if widget is autocomplete or chips
+function isSearchWidgetType(widget) {
+    return _.includes([FormWidgetType.AUTOCOMPLETE, FormWidgetType.TYPEAHEAD, FormWidgetType.CHIPS], widget);
+}
+function onSuccess(response, res, rej) {
+    if (response.error) {
+        rej(response);
+    }
+    else {
+        res(response);
+    }
+}
+export function performDataOperation(dataSource, requestData, options) {
+    return new Promise((res, rej) => {
+        if (dataSource.execute(DataSource.Operation.SUPPORTS_CRUD)) {
+            let fn;
+            const operationType = options.operationType;
+            switch (operationType) {
+                case Live_Operations.UPDATE:
+                    fn = DataSource.Operation.UPDATE_RECORD;
+                    break;
+                case Live_Operations.INSERT:
+                    fn = DataSource.Operation.INSERT_RECORD;
+                    break;
+                case Live_Operations.DELETE:
+                    fn = DataSource.Operation.DELETE_RECORD;
+                    break;
+            }
+            dataSource.execute(fn, requestData).then(response => onSuccess(response, res, rej), rej);
+        }
+        else if (dataSource.execute(DataSource.Operation.IS_API_AWARE)) {
+            if (dataSource.category === "wm.CrudVariable") {
+                const operation = options.operationType === 'insert' ? 'create' : (options.operationType === 'delete' ? 'delete' : 'update');
+                dataSource.execute(DataSource.Operation.INVOKE, {
+                    'skipNotification': true,
+                    'operation': operation,
+                    'inputFields': requestData
+                }).then(res, rej);
+            }
+            else {
+                dataSource.execute(DataSource.Operation.SET_INPUT, requestData);
+                dataSource.execute(DataSource.Operation.INVOKE, {
+                    'skipNotification': true
+                }).then(res, rej);
+            }
+        }
+        else {
+            res(requestData);
+        }
+    });
+}
+export function refreshDataSource(dataSource, options) {
+    return new Promise((res, rej) => {
+        if (!dataSource) {
+            rej();
+            return;
+        }
+        dataSource.execute(DataSource.Operation.LIST_RECORDS, {
+            'filterFields': options.filterFields || {},
+            'orderBy': options.orderBy,
+            'page': options.page || 1,
+            'logicalOp': options.condition || ''
+        }).then(res, rej);
+    });
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.fetchRelatedFieldData
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * This function fetches the data for the related field in live form/ grid
+ *
+ * @param {object} columnDef field definition
+ * @param {string} relatedField related field name
+ * @param {string} datafield Datafield to be set on widget
+ * @param {string} widget Type of the widget
+ * @param {object} elScope element scope
+ * @param {object} parentScope live form// grid scope
+ */
+export function fetchRelatedFieldData(dataSource, formField, options) {
+    let primaryKeys;
+    let displayField;
+    const relatedField = options.relatedField;
+    const datafield = options.datafield;
+    if (!dataSource) {
+        return;
+    }
+    primaryKeys = dataSource.execute(DataSource.Operation.GET_RELATED_PRIMARY_KEYS, relatedField);
+    formField.datafield = datafield;
+    formField._primaryKey = _.isEmpty(primaryKeys) ? undefined : primaryKeys[0];
+    formField.compareby = primaryKeys && primaryKeys.join(',');
+    displayField = datafield === ALLFIELDS ? undefined : datafield;
+    formField.displayfield = displayField = (formField.displayfield || displayField || formField._primaryKey);
+    if (isSearchWidgetType(formField[options.widget])) {
+        formField.dataoptions = { 'relatedField': relatedField, 'filterExpr': formField.filterexpressions ? formField.filterexpressions : {} };
+        formField.datasource = dataSource;
+        formField.searchkey = formField.searchkey || displayField;
+        formField.displaylabel = formField.displayfield = (formField.displaylabel || displayField);
+        if (formField.showPendingSpinner) {
+            formField.showPendingSpinner = false;
+        }
+    }
+    else {
+        interpolateBindExpressions(formField.viewParent, formField.filterexpressions, (filterexpressions) => {
+            formField.filterexpressions = filterexpressions;
+            dataSource.execute(DataSource.Operation.GET_RELATED_TABLE_DATA, {
+                relatedField,
+                pagesize: formField.limit,
+                orderBy: formField.orderby ? _.replace(formField.orderby, /:/g, ' ') : '',
+                filterFields: {},
+                filterExpr: formField.filterexpressions ? formField.filterexpressions : {}
+            }).then(response => {
+                formField.dataset = response.data;
+                formField.displayfield = formField.displayfield || _.head(_.keys(_.get(response, '[0]')));
+                if (formField.showPendingSpinner) {
+                    formField.showPendingSpinner = false;
+                }
+            }, noop);
+        });
+    }
+}
+/**
+ * used to interpolate the bind expression for keys in the query builder
+ * @param context where we find the variable obj
+ * @param filterexpressions - obj containing all the rule objs
+ * @param callbackFn - function to be called with the new replaced values if any in the filterexpressions object
+ */
+export const interpolateBindExpressions = (context, filterexpressions, callbackFn) => {
+    const debouncedFn = debounce(() => {
+        if (_.isFunction(callbackFn)) {
+            callbackFn(filterexpressions);
+        }
+    }, 300);
+    /**
+     * calling the debounced function first for the case where if there is any filterexpression without the bindedvariables.
+     * without this it will never be called. processFilterExpBindNode will be called only for the binded variable expressions.
+     */
+    debouncedFn();
+    const filterExpressions = filterexpressions ? (_.isObject(filterexpressions) ? filterexpressions : JSON.parse(filterexpressions)) : {};
+    const destroyFn = context.registerDestroyListener ? context.registerDestroyListener.bind(context) : _.noop;
+    const filterSubscription = processFilterExpBindNode(context, filterExpressions).subscribe((response) => {
+        filterexpressions = JSON.stringify(response.filterExpressions);
+        debouncedFn();
+    });
+    destroyFn(() => filterSubscription.unsubscribe());
+};
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDistinctFieldProperties
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Returns the properties required for dataset widgets
+ *
+ * @param {object} dataSource variable source for the widget
+ * @param {object} formField definition of the column/ field
+ *
+ */
+export const getDistinctFieldProperties = (dataSource, formField) => {
+    const props = {};
+    let fieldColumn;
+    if (formField['is-related']) {
+        props.tableName = formField['lookup-type'];
+        fieldColumn = formField['lookup-field'];
+        props.distinctField = fieldColumn;
+        props.aliasColumn = fieldColumn.replace('.', '$'); // For related fields, In response . is replaced by $
+        props.filterExpr = formField.filterexpressions ? (_.isObject(formField.filterexpressions) ? formField.filterexpressions : JSON.parse(formField.filterexpressions)) : {};
+    }
+    else {
+        props.tableName = dataSource.execute(DataSource.Operation.GET_ENTITY_NAME);
+        fieldColumn = formField.field || formField.key;
+        props.distinctField = fieldColumn;
+        props.aliasColumn = fieldColumn;
+    }
+    return props;
+};
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDistinctValues
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Returns the distinct values for a field
+ *
+ * @param {object} formField definition of the column/ field
+ * @param {string} widget widget property on the field
+ * @param {object} variable variable for the widget
+ * @param {function} callBack Function to be executed after fetching results
+ *
+ */
+export function getDistinctValues(dataSource, formField, widget) {
+    let props;
+    return new Promise((res, rej) => {
+        if (isDataSetWidget(formField[widget]) && (!formField.isDataSetBound || widget === 'filterwidget')) {
+            props = getDistinctFieldProperties(dataSource, formField);
+            dataSource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {
+                fields: props.distinctField,
+                entityName: props.tableName,
+                pagesize: formField.limit,
+                filterExpr: formField.filterexpressions ? JSON.parse(formField.filterexpressions) : {}
+            }).then(response => {
+                res({ 'field': formField, 'data': response.data, 'aliasColumn': props.aliasColumn });
+            }, rej);
+        }
+    });
+}
+// Set the data field properties on dataset widgets
+function setDataFields(formField, options) {
+    // For search widget, set search key and display label
+    if (isSearchWidgetType(formField[options.widget])) {
+        formField.datafield = options.aliasColumn || LIVE_CONSTANTS.LABEL_KEY;
+        formField.searchkey = options.distinctField || LIVE_CONSTANTS.LABEL_KEY;
+        formField.displaylabel = formField.displayfield = (options.aliasColumn || LIVE_CONSTANTS.LABEL_VALUE);
+        return;
+    }
+    formField.datafield = LIVE_CONSTANTS.LABEL_KEY;
+    formField.displayfield = LIVE_CONSTANTS.LABEL_VALUE;
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#setFieldDataSet
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to set the dataSet on the fields
+ *
+ * @param {object} formField definition of the column/ field
+ * @param {object} data data returned from the server
+ * @param {string} aliasColumn column field name
+ * @param {string} widget widget property on the field
+ * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter
+ *
+ */
+function setFieldDataSet(formField, data, options) {
+    const emptySupportWidgets = [FormWidgetType.SELECT, FormWidgetType.RADIOSET];
+    const emptyOption = {};
+    const dataSet = [];
+    if (options.isEnableEmptyFilter && _.includes(emptySupportWidgets, formField[options.widget]) &&
+        !formField['is-range'] && !formField.multiple) {
+        // If empty option is selected, push an empty object in to dataSet
+        emptyOption[LIVE_CONSTANTS.LABEL_KEY] = LIVE_CONSTANTS.EMPTY_KEY;
+        emptyOption[LIVE_CONSTANTS.LABEL_VALUE] = options.EMPTY_VALUE || LIVE_CONSTANTS.EMPTY_VALUE;
+        dataSet.push(emptyOption);
+    }
+    _.each(data, key => {
+        const value = key[options.aliasColumn];
+        const option = {};
+        if (value !== null && value !== '') {
+            option[LIVE_CONSTANTS.LABEL_KEY] = value;
+            option[LIVE_CONSTANTS.LABEL_VALUE] = value;
+            dataSet.push(option);
+        }
+    });
+    setDataFields(formField, options);
+    formField.dataset = dataSet;
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#fetchDistinctValues
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to fetch the distinct values for a field
+ *
+ * @param {object} scope scope of the widget
+ * @param {object} formFields definitions of the column/ field
+ * @param {string} widget widget property on the field
+ * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter
+ *
+ */
+export function fetchDistinctValues(dataSource, formFields, options) {
+    if (_.isEmpty(formFields)) {
+        return;
+    }
+    formFields.forEach(formField => {
+        getDistinctValuesForField(dataSource, formField, options);
+    });
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.LiveWidgetUtils#getDistinctValuesForField
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to fetch the distinct values for a field
+ *
+ * @param {object} scope scope of the widget
+ * @param {object} formFields definitions of the column/ field
+ * @param {string} widget widget property on the field
+ * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter
+ *
+ */
+export function getDistinctValuesForField(dataSource, formField, options) {
+    if (!dataSource || !formField || formField.isDataSetBound) {
+        return;
+    }
+    if (isSearchWidgetType(formField[options.widget])) {
+        const dataoptions = getDistinctFieldProperties(dataSource, formField);
+        formField.dataoptions = dataoptions;
+        setDataFields(formField, Object.assign(options || {}, dataoptions));
+        formField.datasource = dataSource;
+    }
+    else {
+        interpolateBindExpressions(formField.viewParent, formField.filterexpressions, (filterexpressions) => {
+            formField.filterexpressions = filterexpressions;
+            getDistinctValues(dataSource, formField, options.widget).then((res) => {
+                setFieldDataSet(res.field, res.data, {
+                    aliasColumn: res.aliasColumn,
+                    widget: options.widget,
+                    isEnableEmptyFilter: getEnableEmptyFilter(options.enableemptyfilter),
+                    EMPTY_VALUE: options.EMPTY_VALUE
+                });
+            });
+        });
+    }
+}
+function isDefinedAndNotEmpty(val) {
+    return isDefined(val) && val !== '' && val !== null;
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getRangeFieldValue
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the field value for range
+ *
+ * @param {string} minValue min value selected
+ * @param {string} maxValue max value selected
+ */
+export function getRangeFieldValue(minValue, maxValue) {
+    let fieldValue;
+    if (isDefinedAndNotEmpty(minValue) && isDefinedAndNotEmpty(maxValue)) {
+        fieldValue = [minValue, maxValue];
+    }
+    else if (isDefinedAndNotEmpty(minValue)) {
+        fieldValue = minValue;
+    }
+    else if (isDefinedAndNotEmpty(maxValue)) {
+        fieldValue = maxValue;
+    }
+    return fieldValue;
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getRangeMatchMode
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the match mode for range
+ *
+ * @param {string} minValue min value selected
+ * @param {string} maxValue max value selected
+ */
+export function getRangeMatchMode(minValue, maxValue) {
+    let matchMode;
+    // If two values exists, then it is between. Otherwise, greater or lesser
+    if (isDefinedAndNotEmpty(minValue) && isDefinedAndNotEmpty(maxValue)) {
+        matchMode = MatchMode.BETWEEN;
+    }
+    else if (isDefinedAndNotEmpty(minValue)) {
+        matchMode = MatchMode.GREATER;
+    }
+    else if (isDefinedAndNotEmpty(maxValue)) {
+        matchMode = MatchMode.LESSER;
+    }
+    return matchMode;
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEnableEmptyFilter
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * This function checks if enable filter options is set on live filter
+ *
+ * @param {object} enableemptyfilter empty filter options
+ */
+export function getEnableEmptyFilter(enableemptyfilter) {
+    return enableemptyfilter && _.intersection(enableemptyfilter.split(','), LIVE_CONSTANTS.NULL_EMPTY).length > 0;
+}
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.getEmptyMatchMode
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the match mode based on the filter selected
+ *
+ * @param {object} enableemptyfilter empty filter options
+ */
+export function getEmptyMatchMode(enableemptyfilter) {
+    let matchMode;
+    const emptyFilterOptions = _.split(enableemptyfilter, ',');
+    if (_.intersection(emptyFilterOptions, LIVE_CONSTANTS.NULL_EMPTY).length === 2) {
+        matchMode = MatchMode.NULLOREMPTY;
+    }
+    else if (_.includes(emptyFilterOptions, LIVE_CONSTANTS.NULL)) {
+        matchMode = MatchMode.NULL;
+    }
+    else if (_.includes(emptyFilterOptions, LIVE_CONSTANTS.EMPTY)) {
+        matchMode = MatchMode.EMPTY;
+    }
+    return matchMode;
+}
+/**
+ * converts the data passed to array.
+ *  -> Array: [1,2,3] - [1,2,3]
+ *  -> String: a,b,c - ['a','b','c']
+ *  -> object: {a:1} - [{a:1}]
+ *  -> null - []
+ *  -> undefined - []
+ * @param data
+ * @returns {Array<any>}
+ */
+export const createArrayFrom = (data) => {
+    if (_.isUndefined(data) || _.isNull(data)) {
+        return [];
+    }
+    if (_.isString(data)) {
+        data = data.split(',').map(Function.prototype.call, String.prototype.trim);
+    }
+    if (!_.isArray(data)) {
+        data = [data];
+    }
+    return data;
+};
+/**
+ * @ngdoc function
+ * @name wm.widgets.live.applyFilterOnField
+ * @methodOf wm.widgets.live.LiveWidgetUtils
+ * @function
+ *
+ * @description
+ * Function to get the updated values when filter on field is changed
+ *
+ * @param {object} $scope scope of the filter field/form field
+ * @param {object} filterDef filter/form definition of the field
+ * @param {boolean} isFirst boolean value to check if this method is called on load
+ */
+export function applyFilterOnField(dataSource, filterDef, formFields, newVal, options = {}) {
+    const fieldName = filterDef.field || filterDef.key;
+    const filterOnFields = _.filter(formFields, { 'filter-on': fieldName });
+    newVal = filterDef['is-range'] ? getRangeFieldValue(filterDef.minValue, filterDef.maxValue) : (isDefined(newVal) ? newVal : filterDef.value);
+    if (!dataSource || (options.isFirst && (_.isUndefined(newVal) || newVal === ''))) {
+        return;
+    }
+    // Loop over the fields for which the current field is filter on field
+    _.forEach(filterOnFields, filterField => {
+        const filterKey = filterField.field || filterField.key;
+        const lookUpField = filterDef['lookup-field'] || filterDef._primaryKey;
+        const filterWidget = filterField['edit-widget-type'] || filterField.widgettype;
+        let filterFields = {};
+        let filterOn = filterField['filter-on'];
+        let filterVal;
+        let fieldColumn;
+        let matchMode;
+        if (!isDataSetWidget(filterWidget) || filterField.isDataSetBound || filterOn === filterKey) {
+            return;
+        }
+        // For related fields, add lookupfield for query generation
+        if (filterDef && filterDef['is-related']) {
+            filterOn += '.' + lookUpField;
+        }
+        if (isDefined(newVal)) {
+            if (filterDef['is-range']) {
+                matchMode = getRangeMatchMode(filterDef.minValue, filterDef.maxValue);
+            }
+            else if (getEnableEmptyFilter(options.enableemptyfilter) && newVal === LIVE_CONSTANTS.EMPTY_KEY) {
+                matchMode = getEmptyMatchMode(options.enableemptyfilter);
+            }
+            else {
+                matchMode = MatchMode.EQUALS;
+            }
+            filterVal = (_.isObject(newVal) && !_.isArray(newVal)) ? newVal[lookUpField] : newVal;
+            filterFields[filterOn] = {
+                'value': filterVal,
+                'matchMode': matchMode
+            };
+        }
+        else {
+            filterFields = {};
+        }
+        fieldColumn = filterKey;
+        if (isSearchWidgetType(filterWidget) && filterField.dataoptions) {
+            filterField.dataoptions.filterFields = filterFields;
+        }
+        else {
+            dataSource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {
+                'fields': fieldColumn,
+                'filterFields': filterFields,
+                'pagesize': filterField.limit
+            }).then(response => {
+                setFieldDataSet(filterField, response.data, {
+                    aliasColumn: fieldColumn,
+                    widget: options.widget || 'widgettype',
+                    isEnableEmptyFilter: getEnableEmptyFilter(options.enableemptyfilter),
+                    EMPTY_VALUE: options.EMPTY_VALUE
+                });
+            }, noop);
+        }
+    });
+}
+// Transform data as required by data table
+export function transformData(dataObject, variableName) {
+    let newObj, tempArr, keys, oldKeys, numKeys, newObject, tempObj;
+    // data sanity testing
+    dataObject = dataObject || [];
+    // if the dataObject is not an array make it an array
+    if (!_.isArray(dataObject)) {
+        // if the data returned is of type string, make it an object inside an array
+        if (_.isString(dataObject)) {
+            keys = variableName.substring(variableName.indexOf('.') + 1, variableName.length).split('.');
+            oldKeys = [];
+            numKeys = keys.length;
+            newObject = {};
+            tempObj = newObject;
+            // loop over the keys to form appropriate data object required for grid
+            keys.forEach((key, index) => {
+                // loop over old keys to create new object at the iterative level
+                oldKeys.forEach(oldKey => {
+                    tempObj = newObject[oldKey];
+                });
+                tempObj[key] = index === numKeys - 1 ? dataObject : {};
+                oldKeys.push(key);
+            });
+            // change the string data to the new dataObject formed
+            dataObject = newObject;
+        }
+        dataObject = [dataObject];
+    }
+    else {
+        /*if the dataObject is an array and each value is a string, then lite-transform the string to an object
+         * lite-transform: just checking if the first value is string and then transforming the object, instead of traversing through the whole array
+         * */
+        if (_.isString(dataObject[0])) {
+            tempArr = [];
+            _.forEach(dataObject, str => {
+                newObj = {};
+                newObj[variableName.split('.').join('-')] = str;
+                tempArr.push(newObj);
+            });
+            dataObject = tempArr;
+        }
+    }
+    return dataObject;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-utils.js","sourceRoot":"","sources":["../../../../../projects/components/base/src/utils/data-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { DataSource, debounce, processFilterExpBindNode } from '@wm/core';\nimport { FormWidgetType, isDefined, MatchMode } from '@wm/core';\n\nimport { isDataSetWidget } from './widget-utils';\n\ndeclare const _;\n\nconst noop = () => { };\n\nexport enum Live_Operations {\n    INSERT = 'insert',\n    UPDATE = 'update',\n    DELETE = 'delete',\n    READ = 'read'\n}\n\nexport const ALLFIELDS = 'All Fields';\n\nexport const LIVE_CONSTANTS = {\n    'EMPTY_KEY': 'EMPTY_NULL_FILTER',\n    'EMPTY_VALUE': 'No Value',\n    'LABEL_KEY': 'key',\n    'LABEL_VALUE': 'value',\n    'NULL_EMPTY': ['null', 'empty'],\n    'NULL': 'null',\n    'EMPTY': 'empty'\n};\n\n// Returns true if widget is autocomplete or chips\nfunction isSearchWidgetType(widget) {\n    return _.includes([FormWidgetType.AUTOCOMPLETE, FormWidgetType.TYPEAHEAD, FormWidgetType.CHIPS], widget);\n}\n\nfunction onSuccess(response, res, rej) {\n    if (response.error) {\n        rej(response);\n    } else {\n        res(response);\n    }\n}\n\nexport function performDataOperation(dataSource, requestData, options): Promise<any> {\n    return new Promise((res, rej) => {\n        if (dataSource.execute(DataSource.Operation.SUPPORTS_CRUD)) {\n            let fn;\n            const operationType = options.operationType;\n            switch (operationType) {\n                case Live_Operations.UPDATE:\n                    fn = DataSource.Operation.UPDATE_RECORD;\n                    break;\n                case Live_Operations.INSERT:\n                    fn = DataSource.Operation.INSERT_RECORD;\n                    break;\n                case Live_Operations.DELETE:\n                    fn = DataSource.Operation.DELETE_RECORD;\n                    break;\n            }\n            dataSource.execute(fn, requestData).then(response => onSuccess(response, res, rej), rej);\n        } else if (dataSource.execute(DataSource.Operation.IS_API_AWARE)) {\n            if(dataSource.category === \"wm.CrudVariable\") {\n                const operation = options.operationType === 'insert' ? 'create' : (options.operationType === 'delete' ? 'delete' : 'update');\n                dataSource.execute(DataSource.Operation.INVOKE, {\n                    'skipNotification': true,\n                    'operation': operation,\n                    'inputFields': requestData\n                }).then(res, rej);\n            } else {\n                dataSource.execute(DataSource.Operation.SET_INPUT, requestData);\n                dataSource.execute(DataSource.Operation.INVOKE, {\n                    'skipNotification': true\n                }).then(res, rej);\n            }\n        } else {\n            res(requestData);\n        }\n    });\n}\n\nexport function refreshDataSource(dataSource, options): Promise<any> {\n    return new Promise((res, rej) => {\n        if (!dataSource) {\n            rej();\n            return;\n        }\n        dataSource.execute(DataSource.Operation.LIST_RECORDS, {\n            'filterFields': options.filterFields || {},\n            'orderBy': options.orderBy,\n            'page': options.page || 1,\n            'logicalOp' : options.condition || ''\n        }).then(res, rej);\n    });\n}\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.fetchRelatedFieldData\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * This function fetches the data for the related field in live form/ grid\n *\n * @param {object} columnDef field definition\n * @param {string} relatedField related field name\n * @param {string} datafield Datafield to be set on widget\n * @param {string} widget Type of the widget\n * @param {object} elScope element scope\n * @param {object} parentScope live form// grid scope\n */\nexport function fetchRelatedFieldData(dataSource, formField, options) {\n    let primaryKeys;\n    let displayField;\n    const relatedField = options.relatedField;\n    const datafield = options.datafield;\n\n    if (!dataSource) {\n        return;\n    }\n    primaryKeys = dataSource.execute(DataSource.Operation.GET_RELATED_PRIMARY_KEYS, relatedField);\n    formField.datafield = datafield;\n    formField._primaryKey = _.isEmpty(primaryKeys) ? undefined : primaryKeys[0];\n    formField.compareby = primaryKeys && primaryKeys.join(',');\n\n    displayField = datafield === ALLFIELDS ? undefined : datafield;\n    formField.displayfield = displayField = (formField.displayfield || displayField || formField._primaryKey);\n\n    if (isSearchWidgetType(formField[options.widget])) {\n        formField.dataoptions = { 'relatedField': relatedField, 'filterExpr': formField.filterexpressions ? formField.filterexpressions : {} };\n        formField.datasource = dataSource;\n        formField.searchkey = formField.searchkey || displayField;\n        formField.displaylabel = formField.displayfield = (formField.displaylabel || displayField);\n        if (formField.showPendingSpinner) {\n            formField.showPendingSpinner = false;\n        }\n    } else {\n        interpolateBindExpressions(formField.viewParent, formField.filterexpressions, (filterexpressions) => {\n            formField.filterexpressions = filterexpressions;\n            dataSource.execute(DataSource.Operation.GET_RELATED_TABLE_DATA, {\n                relatedField,\n                pagesize: formField.limit,\n                orderBy: formField.orderby ? _.replace(formField.orderby, /:/g, ' ') : '',\n                filterFields: {},\n                filterExpr: formField.filterexpressions ? formField.filterexpressions : {}\n            }).then(response => {\n                formField.dataset = response.data;\n                formField.displayfield = formField.displayfield || _.head(_.keys(_.get(response, '[0]')));\n                if (formField.showPendingSpinner) {\n                    formField.showPendingSpinner = false;\n                }\n            }, noop);\n        });\n    }\n}\n\n/**\n * used to interpolate the bind expression for keys in the query builder\n * @param context where we find the variable obj\n * @param filterexpressions - obj containing all the rule objs\n * @param callbackFn - function to be called with the new replaced values if any in the filterexpressions object\n */\nexport const interpolateBindExpressions = (context, filterexpressions, callbackFn) => {\n    const debouncedFn = debounce(() => {\n        if (_.isFunction(callbackFn)) {\n            callbackFn(filterexpressions);\n        }\n    }, 300);\n\n    /**\n     * calling the debounced function first for the case where if there is any filterexpression without the bindedvariables.\n     * without this it will never be called. processFilterExpBindNode will be called only for the binded variable expressions.\n     */\n    debouncedFn();\n    const filterExpressions = filterexpressions ? (_.isObject(filterexpressions) ? filterexpressions : JSON.parse(filterexpressions)) : {};\n    const destroyFn = context.registerDestroyListener ? context.registerDestroyListener.bind(context) : _.noop;\n    const filterSubscription = processFilterExpBindNode(context, filterExpressions).subscribe((response: any) => {\n        filterexpressions = JSON.stringify(response.filterExpressions);\n        debouncedFn();\n    });\n    destroyFn(() => filterSubscription.unsubscribe());\n};\n/**\n * @ngdoc function\n * @name wm.widgets.live.LiveWidgetUtils#getDistinctFieldProperties\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Returns the properties required for dataset widgets\n *\n * @param {object} dataSource variable source for the widget\n * @param {object} formField definition of the column/ field\n *\n */\nexport const getDistinctFieldProperties = (dataSource, formField) => {\n    const props: any = {};\n    let fieldColumn;\n    if (formField['is-related']) {\n        props.tableName = formField['lookup-type'];\n        fieldColumn = formField['lookup-field'];\n        props.distinctField = fieldColumn;\n        props.aliasColumn = fieldColumn.replace('.', '$'); // For related fields, In response . is replaced by $\n        props.filterExpr = formField.filterexpressions ? (_.isObject(formField.filterexpressions) ? formField.filterexpressions : JSON.parse(formField.filterexpressions)) : {};\n    } else {\n        props.tableName = dataSource.execute(DataSource.Operation.GET_ENTITY_NAME);\n        fieldColumn = formField.field || formField.key;\n        props.distinctField = fieldColumn;\n        props.aliasColumn = fieldColumn;\n    }\n    return props;\n};\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.LiveWidgetUtils#getDistinctValues\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Returns the distinct values for a field\n *\n * @param {object} formField definition of the column/ field\n * @param {string} widget widget property on the field\n * @param {object} variable variable for the widget\n * @param {function} callBack Function to be executed after fetching results\n *\n */\nexport function getDistinctValues(dataSource, formField, widget) {\n    let props;\n\n    return new Promise((res, rej) => {\n        if (isDataSetWidget(formField[widget]) && (!formField.isDataSetBound || widget === 'filterwidget')) {\n            props = getDistinctFieldProperties(dataSource, formField);\n            dataSource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {\n                fields: props.distinctField,\n                entityName: props.tableName,\n                pagesize: formField.limit,\n                filterExpr: formField.filterexpressions ? JSON.parse(formField.filterexpressions) : {}\n            }).then(response => {\n                res({ 'field': formField, 'data': response.data, 'aliasColumn': props.aliasColumn });\n            }, rej);\n        }\n    });\n}\n\n// Set the data field properties on dataset widgets\nfunction setDataFields(formField, options?) {\n    // For search widget, set search key and display label\n    if (isSearchWidgetType(formField[options.widget])) {\n        formField.datafield = options.aliasColumn || LIVE_CONSTANTS.LABEL_KEY;\n        formField.searchkey = options.distinctField || LIVE_CONSTANTS.LABEL_KEY;\n        formField.displaylabel = formField.displayfield = (options.aliasColumn || LIVE_CONSTANTS.LABEL_VALUE);\n        return;\n    }\n    formField.datafield = LIVE_CONSTANTS.LABEL_KEY;\n    formField.displayfield = LIVE_CONSTANTS.LABEL_VALUE;\n}\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.LiveWidgetUtils#setFieldDataSet\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to set the dataSet on the fields\n *\n * @param {object} formField definition of the column/ field\n * @param {object} data data returned from the server\n * @param {string} aliasColumn column field name\n * @param {string} widget widget property on the field\n * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter\n *\n */\nfunction setFieldDataSet(formField, data, options?) {\n    const emptySupportWidgets = [FormWidgetType.SELECT, FormWidgetType.RADIOSET];\n    const emptyOption = {};\n    const dataSet = [];\n    if (options.isEnableEmptyFilter && _.includes(emptySupportWidgets, formField[options.widget]) &&\n        !formField['is-range'] && !formField.multiple) {\n        // If empty option is selected, push an empty object in to dataSet\n        emptyOption[LIVE_CONSTANTS.LABEL_KEY] = LIVE_CONSTANTS.EMPTY_KEY;\n        emptyOption[LIVE_CONSTANTS.LABEL_VALUE] = options.EMPTY_VALUE || LIVE_CONSTANTS.EMPTY_VALUE;\n        dataSet.push(emptyOption);\n    }\n    _.each(data, key => {\n        const value = key[options.aliasColumn];\n        const option = {};\n        if (value !== null && value !== '') {\n            option[LIVE_CONSTANTS.LABEL_KEY] = value;\n            option[LIVE_CONSTANTS.LABEL_VALUE] = value;\n            dataSet.push(option);\n        }\n    });\n    setDataFields(formField, options);\n    formField.dataset = dataSet;\n}\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.LiveWidgetUtils#fetchDistinctValues\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to fetch the distinct values for a field\n *\n * @param {object} scope scope of the widget\n * @param {object} formFields definitions of the column/ field\n * @param {string} widget widget property on the field\n * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter\n *\n */\nexport function fetchDistinctValues(dataSource, formFields, options) {\n    if (_.isEmpty(formFields)) {\n        return;\n    }\n    formFields.forEach(formField => {\n        getDistinctValuesForField(dataSource, formField, options);\n    });\n}\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.LiveWidgetUtils#getDistinctValuesForField\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to fetch the distinct values for a field\n *\n * @param {object} scope scope of the widget\n * @param {object} formFields definitions of the column/ field\n * @param {string} widget widget property on the field\n * @param {boolean} isEnableEmptyFilter is null or empty values allowed on filter\n *\n */\nexport function getDistinctValuesForField(dataSource, formField, options?) {\n    if (!dataSource || !formField || formField.isDataSetBound) {\n        return;\n    }\n    if (isSearchWidgetType(formField[options.widget])) {\n        const dataoptions = getDistinctFieldProperties(dataSource, formField);\n        formField.dataoptions = dataoptions;\n        setDataFields(formField, Object.assign(options || {}, dataoptions));\n        formField.datasource = dataSource;\n    } else {\n        interpolateBindExpressions(formField.viewParent, formField.filterexpressions, (filterexpressions) => {\n            formField.filterexpressions = filterexpressions;\n            getDistinctValues(dataSource, formField, options.widget).then((res: any) => {\n                setFieldDataSet(res.field, res.data, {\n                    aliasColumn: res.aliasColumn,\n                    widget: options.widget,\n                    isEnableEmptyFilter: getEnableEmptyFilter(options.enableemptyfilter),\n                    EMPTY_VALUE: options.EMPTY_VALUE\n                });\n            });\n        });\n    }\n}\n\nfunction isDefinedAndNotEmpty(val) {\n    return isDefined(val) && val !== '' && val !== null;\n}\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.getRangeFieldValue\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to get the field value for range\n *\n * @param {string} minValue min value selected\n * @param {string} maxValue max value selected\n */\nexport function getRangeFieldValue(minValue, maxValue) {\n    let fieldValue;\n    if (isDefinedAndNotEmpty(minValue) && isDefinedAndNotEmpty(maxValue)) {\n        fieldValue = [minValue, maxValue];\n    } else if (isDefinedAndNotEmpty(minValue)) {\n        fieldValue = minValue;\n    } else if (isDefinedAndNotEmpty(maxValue)) {\n        fieldValue = maxValue;\n    }\n    return fieldValue;\n}\n/**\n * @ngdoc function\n * @name wm.widgets.live.getRangeMatchMode\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to get the match mode for range\n *\n * @param {string} minValue min value selected\n * @param {string} maxValue max value selected\n */\nexport function getRangeMatchMode(minValue, maxValue) {\n    let matchMode;\n    // If two values exists, then it is between. Otherwise, greater or lesser\n    if (isDefinedAndNotEmpty(minValue) && isDefinedAndNotEmpty(maxValue)) {\n        matchMode = MatchMode.BETWEEN;\n    } else if (isDefinedAndNotEmpty(minValue)) {\n        matchMode = MatchMode.GREATER;\n    } else if (isDefinedAndNotEmpty(maxValue)) {\n        matchMode = MatchMode.LESSER;\n    }\n    return matchMode;\n}\n/**\n * @ngdoc function\n * @name wm.widgets.live.getEnableEmptyFilter\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * This function checks if enable filter options is set on live filter\n *\n * @param {object} enableemptyfilter empty filter options\n */\nexport function getEnableEmptyFilter(enableemptyfilter) {\n    return enableemptyfilter && _.intersection(enableemptyfilter.split(','), LIVE_CONSTANTS.NULL_EMPTY).length > 0;\n}\n/**\n * @ngdoc function\n * @name wm.widgets.live.getEmptyMatchMode\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to get the match mode based on the filter selected\n *\n * @param {object} enableemptyfilter empty filter options\n */\nexport function getEmptyMatchMode(enableemptyfilter) {\n    let matchMode;\n    const emptyFilterOptions = _.split(enableemptyfilter, ',');\n    if (_.intersection(emptyFilterOptions, LIVE_CONSTANTS.NULL_EMPTY).length === 2) {\n        matchMode = MatchMode.NULLOREMPTY;\n    } else if (_.includes(emptyFilterOptions, LIVE_CONSTANTS.NULL)) {\n        matchMode = MatchMode.NULL;\n    } else if (_.includes(emptyFilterOptions, LIVE_CONSTANTS.EMPTY)) {\n        matchMode = MatchMode.EMPTY;\n    }\n    return matchMode;\n}\n\n/**\n * converts the data passed to array.\n *  -> Array: [1,2,3] - [1,2,3]\n *  -> String: a,b,c - ['a','b','c']\n *  -> object: {a:1} - [{a:1}]\n *  -> null - []\n *  -> undefined - []\n * @param data\n * @returns {Array<any>}\n */\nexport const createArrayFrom = (data): Array<any> => {\n\n    if (_.isUndefined(data) || _.isNull(data)) {\n        return [];\n    }\n\n    if (_.isString(data)) {\n        data = data.split(',').map(Function.prototype.call, String.prototype.trim);\n    }\n\n    if (!_.isArray(data)) {\n        data = [data];\n    }\n\n    return data;\n};\n\n/**\n * @ngdoc function\n * @name wm.widgets.live.applyFilterOnField\n * @methodOf wm.widgets.live.LiveWidgetUtils\n * @function\n *\n * @description\n * Function to get the updated values when filter on field is changed\n *\n * @param {object} $scope scope of the filter field/form field\n * @param {object} filterDef filter/form definition of the field\n * @param {boolean} isFirst boolean value to check if this method is called on load\n */\nexport function applyFilterOnField(dataSource, filterDef, formFields, newVal, options: any = {}) {\n    const fieldName = filterDef.field || filterDef.key;\n    const filterOnFields = _.filter(formFields, { 'filter-on': fieldName });\n\n    newVal = filterDef['is-range'] ? getRangeFieldValue(filterDef.minValue, filterDef.maxValue) : (isDefined(newVal) ? newVal : filterDef.value);\n    if (!dataSource || (options.isFirst && (_.isUndefined(newVal) || newVal === ''))) {\n        return;\n    }\n    // Loop over the fields for which the current field is filter on field\n    _.forEach(filterOnFields, filterField => {\n        const filterKey = filterField.field || filterField.key;\n        const lookUpField = filterDef['lookup-field'] || filterDef._primaryKey;\n        const filterWidget = filterField['edit-widget-type'] || filterField.widgettype;\n        let filterFields = {};\n        let filterOn = filterField['filter-on'];\n        let filterVal;\n        let fieldColumn;\n        let matchMode;\n        if (!isDataSetWidget(filterWidget) || filterField.isDataSetBound || filterOn === filterKey) {\n            return;\n        }\n        // For related fields, add lookupfield for query generation\n        if (filterDef && filterDef['is-related']) {\n            filterOn += '.' + lookUpField;\n        }\n        if (isDefined(newVal)) {\n            if (filterDef['is-range']) {\n                matchMode = getRangeMatchMode(filterDef.minValue, filterDef.maxValue);\n            } else if (getEnableEmptyFilter(options.enableemptyfilter) && newVal === LIVE_CONSTANTS.EMPTY_KEY) {\n                matchMode = getEmptyMatchMode(options.enableemptyfilter);\n            } else {\n                matchMode = MatchMode.EQUALS;\n            }\n            filterVal = (_.isObject(newVal) && !_.isArray(newVal)) ? newVal[lookUpField] : newVal;\n            filterFields[filterOn] = {\n                'value': filterVal,\n                'matchMode': matchMode\n            };\n        } else {\n            filterFields = {};\n        }\n        fieldColumn = filterKey;\n\n        if (isSearchWidgetType(filterWidget) && filterField.dataoptions) {\n            filterField.dataoptions.filterFields = filterFields;\n        } else {\n            dataSource.execute(DataSource.Operation.GET_DISTINCT_DATA_BY_FIELDS, {\n                'fields': fieldColumn,\n                'filterFields': filterFields,\n                'pagesize': filterField.limit\n            }).then(response => {\n                setFieldDataSet(filterField, response.data, {\n                    aliasColumn: fieldColumn,\n                    widget: options.widget || 'widgettype',\n                    isEnableEmptyFilter: getEnableEmptyFilter(options.enableemptyfilter),\n                    EMPTY_VALUE: options.EMPTY_VALUE\n                });\n            }, noop);\n        }\n    });\n}\n\n// Transform data as required by data table\nexport function transformData(dataObject, variableName) {\n    let newObj,\n        tempArr,\n        keys,\n        oldKeys,\n        numKeys,\n        newObject,\n        tempObj;\n\n    // data sanity testing\n    dataObject = dataObject || [];\n    // if the dataObject is not an array make it an array\n    if (!_.isArray(dataObject)) {\n        // if the data returned is of type string, make it an object inside an array\n        if (_.isString(dataObject)) {\n            keys = variableName.substring(variableName.indexOf('.') + 1, variableName.length).split('.');\n            oldKeys = [];\n            numKeys = keys.length;\n            newObject = {};\n            tempObj = newObject;\n\n            // loop over the keys to form appropriate data object required for grid\n            keys.forEach((key, index) => {\n                // loop over old keys to create new object at the iterative level\n                oldKeys.forEach(oldKey => {\n                    tempObj = newObject[oldKey];\n                });\n                tempObj[key] = index === numKeys - 1 ? dataObject : {};\n                oldKeys.push(key);\n            });\n\n            // change the string data to the new dataObject formed\n            dataObject = newObject;\n        }\n        dataObject = [dataObject];\n    } else {\n        /*if the dataObject is an array and each value is a string, then lite-transform the string to an object\n         * lite-transform: just checking if the first value is string and then transforming the object, instead of traversing through the whole array\n         * */\n        if (_.isString(dataObject[0])) {\n            tempArr = [];\n            _.forEach(dataObject, str => {\n                newObj = {};\n                newObj[variableName.split('.').join('-')] = str;\n                tempArr.push(newObj);\n            });\n            dataObject = tempArr;\n        }\n    }\n    return dataObject;\n}\n"]}