@datarailsshared/dr_renderer 1.2.316-dragons → 1.2.318-rocket

package/src/highcharts_renderer.js

@@ -1150,7 +1150,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 ob.name = row_n_value.join(highchartsRenderer.delimer)
                     .replace(highchartsRenderer.DR_OTHERS_KEY, othersName);
             }
-
             lodash.forEach(col_n_keys, function (col_n_value, index) {
                 var agg = pivotData.getAggregator(row_n_value, col_n_value);
                 var val = agg.value();
@@ -1392,7 +1391,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             if (opts.trendLine) {
                 const a = ((ySum * squareXSum) - (xSum * xySum)) / ((n * squareXSum) - (xSum * xSum));
                 const b = ((n * xySum) -  (xSum* ySum)) / ((n * squareXSum) - (xSum * xSum));
-
                 const trendSeries = lodash.clone(chart_series[chart_series.length - 1]);
                 trendSeries.className = 'trendSeries';
                 trendSeries.name = highchartsRenderer.getTrendSeriesName(trendSeries);
@@ -1403,7 +1401,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 if (colors && colors[i]) {
                     trendSeries.color = colors[i];
                 }
-
                 trendSerieses.push(trendSeries);
             }
             i++;
@@ -1420,7 +1417,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         }
 
         let weights = { line: 2,spline: 3 ,area:-2, areaspline: -1, scatter:4, column: 1 };
-
         if (opts.comboOptions && lodash.includes(chartType,'combo') && !lodash.isEqual(row_n_keys, EMPTY_ROW_N_KEYS)) {
             chart_series.forEach((series, seriesIndex) => {
                 const savedSeriesOption = lodash.find(opts.comboOptions.seriesOptions, {series: series.name});
@@ -1464,7 +1460,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 totalSeries.color = colors[i];
             }
 
-        if (!lodash.isEmpty(pivotData.colTotals)) {
             col_n_keys.forEach(columnKey => {
                 let key = columnKey;
                 let totalKey = columnKey;
@@ -1475,18 +1470,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 const value = pivotData.colTotals[totalKey] ? pivotData.colTotals[totalKey].value() : 0;
                 totalSeries.data.push({name: lodash.unescape(key), y: value});
             });
-        } else {
-            lodash.forEach(row_n_keys, (rowKey, index) => {
-                let key = rowKey;
-                let totalKey = rowKey;
-                if (lodash.isArray(rowKey)) {
-                    key = col_n_keys[index];
-                    totalKey = totalKey.join(highchartsRenderer.delimer);
-                }
-                const value = pivotData.rowTotals[totalKey] ? pivotData.rowTotals[totalKey].value() : 0;
-                totalSeries.data.push({name: lodash.unescape(key), y: value});
-            });
-        }
 
             chart_series.push(totalSeries);
         }
@@ -1507,7 +1490,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         const chart_series = [];
         const row_n_keys = pivotData.getRowKeys();
         const col_n_keys = pivotData.getColKeys();
-        const rows_by_cols = pivotData.rowKeysByCols;
 
         let resultObject = {
             data: [],
@@ -1536,9 +1518,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             });
 
             if (col_index !== col_n_keys.length - 1) {
-
-                const rowKeys = rows_by_cols ? rows_by_cols[col_index] : row_n_keys;
-                lodash.forEach(rowKeys, function (row_n_value) {
+                lodash.forEach(row_n_keys, function (row_n_value) {
                     const agg = pivotData.getAggregator(row_n_value, col_n_value);
                     let val = agg.value();
 
@@ -4428,42 +4408,72 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         return ret_str;
     };
 
-    highchartsRenderer.getSortingByValueOrderList = function (pivotData, sortingOptions, keysArray, attrs, fieldIndex, widget) {
-        let values_names_arr = [];
-        lodash.forEach(keysArray, function (val) {
-            const firstArray = [];
-            const secondArray = val.slice(0, fieldIndex + 1);
-
-            let valueForComparison;
-            if (sortingOptions.sort_by === 'variance') {
-                const varianceConfig = widget.options.chartOptions.delta_column;
-                const data = pivotData.input;
-                const varianceField = varianceConfig.field === 'category' ? widget.cols[0] : widget.rows[0];
-                const varianceRowsForCurrentKey = lodash.filter(data, row => 
-                    row[varianceField.name] === varianceConfig.name 
-                        && lodash.every(secondArray, (item, index) => row[attrs[index]] === item)
-                );
+    highchartsRenderer.getNewAttrSortingForCol = function (pivotData, sortingOptions) {
+        let rowAttrs, rowKeys, colKeys, colAttrs;
+        rowAttrs = pivotData.rowAttrs;
+        rowKeys = pivotData.rowKeys;
+        colKeys = pivotData.colKeys;
+        colAttrs = pivotData.colAttrs;
 
-                valueForComparison = lodash.reduce(varianceRowsForCurrentKey, (a, d) => a + d[widget.vals[0].name], 0);
-            } else {
-                let getAggregatorParams = [firstArray, secondArray];
 
-                if (lodash.includes(pivotData.rowAttrs, attrs[fieldIndex])) {
-                    getAggregatorParams = lodash.reverse(getAggregatorParams);
-                }
-    
-                let aggregator_subtotal = pivotData.getAggregator(...getAggregatorParams);
+        if (!colAttrs || colAttrs.length == 0) {
+            return null;
+        }
+
+        let values_names_arr = [];
+        let keysArray = sortingOptions.field ? rowKeys : colKeys;
+
+        lodash.forEach(keysArray, function (val) {
+            let firstArray = sortingOptions.field ? [val[0]] : [];
+            let secondArray = sortingOptions.field ? sortingOptions.field.split(highchartsRenderer.delimer) : [val[0]];
+            let aggregator_subtotal = pivotData.getAggregator(firstArray, secondArray);
 
-                if (aggregator_subtotal) {
-                    valueForComparison = aggregator_subtotal.value();
+            if (aggregator_subtotal) {
+                let value_subtotal = aggregator_subtotal.value();
+                if (sortingOptions && sortingOptions.is_absolute && !isNaN(parseFloat(value_subtotal))) {
+                    value_subtotal = Math.abs(value_subtotal);
                 }
+                values_names_arr.push({name: val[0], value: value_subtotal});
             }
+        });
+
+        // ORDERING
+        let sorting_vector = ['asc'];
+        if (sortingOptions && sortingOptions.type == 'largestToSmallest') {
+            sorting_vector = ['desc'];
+        }
+        values_names_arr = lodash.orderBy(values_names_arr, ['value'], sorting_vector);
 
-            if (!lodash.isNil(valueForComparison)) {
-                if (sortingOptions && sortingOptions.is_absolute && !isNaN(parseFloat(valueForComparison))) {
-                    valueForComparison = Math.abs(valueForComparison);
+        // map only names
+        let attr_sorted_values = lodash.map(values_names_arr, 'name');
+        return {name: sortingOptions.field ? rowAttrs[0] : colAttrs[0], values: attr_sorted_values};
+    };
+
+    highchartsRenderer.getNewAttrSortingForRow = function (pivotData, sortingOptions) {
+        let rowAttrs, rowKeys, colKeys, colAttrs;
+        rowAttrs = pivotData.rowAttrs;
+        rowKeys = pivotData.rowKeys;
+        colKeys = pivotData.colKeys;
+        colAttrs = pivotData.colAttrs;
+
+        if (!rowAttrs || rowAttrs.length == 0) {
+            return null;
+        }
+
+        let values_names_arr = [];
+        let keysArray = sortingOptions.field ? colKeys : rowKeys;
+
+        lodash.forEach(keysArray, function (val) {
+            let firstArray = sortingOptions.field ? sortingOptions.field.split(highchartsRenderer.delimer) : [val[0]];
+            let secondArray = sortingOptions.field ? [val[0]] : [];
+            let aggregator_subtotal = pivotData.getAggregator(firstArray, secondArray);
+
+            if (aggregator_subtotal) {
+                let value_subtotal = aggregator_subtotal.value();
+                if (sortingOptions && sortingOptions.is_absolute && !isNaN(parseFloat(value_subtotal))) {
+                    value_subtotal = Math.abs(value_subtotal);
                 }
-                values_names_arr.push({name: secondArray.join(','), value: valueForComparison});
+                values_names_arr.push({name: val[0], value: value_subtotal});
             }
         });
 
@@ -4475,33 +4485,36 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         values_names_arr = lodash.orderBy(values_names_arr, ['value'], sorting_vector);
 
         // map only names
-        return lodash.map(values_names_arr, 'name');
+        let attr_sorted_values = lodash.map(values_names_arr, 'name');
+        return {name: sortingOptions.field ? colAttrs[0] : rowAttrs[0], values: attr_sorted_values};
     };
 
-    highchartsRenderer.generateSortingFunctionByValues = function (sortByValueSettings, pivotData, opts, widget) {
+    highchartsRenderer.generateSortingFunctionByValues = function (sortingOptions, pivotData, opts) {
+        let new_map;
+        let axis = highchartsRenderer.getAxis(sortingOptions.axis, opts);
+        if (axis == 'col_total') {
+            new_map = highchartsRenderer.getNewAttrSortingForCol(pivotData, sortingOptions);
+        } else if (axis == 'row_total') {
+            new_map = highchartsRenderer.getNewAttrSortingForRow(pivotData, sortingOptions);
+        }
+
         let old_sorters_function = opts.sorters;
         if (!old_sorters_function) {
             old_sorters_function = function () {
             };
         }
-        return function (attr) {
-            const sortingOptions = lodash.find(sortByValueSettings, fieldSorting => fieldSorting.name === attr);
-            if (sortingOptions) {
-                const axis = highchartsRenderer.getAxis(_.includes(pivotData.colAttrs, attr) ? 'col_total' : 'row_total', opts);
-                const isColumnSort = axis === 'col_total';
-                const fieldIndex = lodash.findIndex(isColumnSort ? pivotData.colAttrs : pivotData.rowAttrs, name => name === attr);
-                const orderedNamesList = highchartsRenderer.getSortingByValueOrderList(
-                    pivotData,
-                    sortingOptions.sorting,
-                    pivotData[isColumnSort ? 'colKeys' : 'rowKeys'],
-                    pivotData[isColumnSort ? 'colAttrs' : 'rowAttrs'],
-                    fieldIndex,
-                    widget
-                );
-                return $.pivotUtilities.sortAs(orderedNamesList);
-            } else {
-                return old_sorters_function(attr);
+        if (new_map) {
+            var sortAs = $.pivotUtilities.sortAs;
+            let new_sorters_function = function (attr) {
+                if (new_map.name == attr) {
+                    return $.pivotUtilities.sortAs(new_map.values);
+                } else {
+                    return old_sorters_function(attr);
+                }
             }
+            return new_sorters_function;
+        } else {
+            return old_sorters_function;
         }
     };
 
@@ -4705,7 +4718,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         result = null;
         try {
             pivotData = $.pivotUtilities.getPivotDataModel(rowData, opts);
-            pivotData.sortByValueAttrs = [];
             try {
                 if (options && options.onlyOptions) {
                     if (!opts.rendererOptions) {
@@ -4713,20 +4725,12 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                     }
                     opts.rendererOptions.onlyOptions = true;
                 }
-
-                if (!highchartsRenderer.isSortingOnBackendEnabled()) {
-                    const sortByValueSettings = lodash.filter(
-                        lodash.get(widget, 'options.sortingFields', []),
-                        sortingField => lodash.includes(['field_values', 'variance'], lodash.get(sortingField, 'sorting.sort_by'))
-                    );
-    
-                    if (sortByValueSettings.length) {
-                        pivotData.sortByValueAttrs = lodash.map(sortByValueSettings, fieldSorting => fieldSorting.name);
-                        let new_sorting_function = highchartsRenderer.generateSortingFunctionByValues(sortByValueSettings, pivotData, opts, widget);
-                        opts.sorters = new_sorting_function;
-                        optsFiltered.sorters = new_sorting_function;
-                        pivotData.sorters = new_sorting_function;
-                    }
+                var totalFilters = lodash.get(opts, 'rendererOptions.total_value_options', null);
+                if (totalFilters && totalFilters.sorting_options) {
+                    let new_sorting_function = highchartsRenderer.generateSortingFunctionByValues(totalFilters.sorting_options, pivotData, opts);
+                    opts.sorters = new_sorting_function;
+                    optsFiltered.sorters = new_sorting_function;
+                    pivotData.sorters = new_sorting_function;
                 }
 
                 result = opts.renderer(pivotData, opts.rendererOptions);
@@ -4780,7 +4784,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             rows: lodash.map(pivotOptions.legendArray, 'name'),
             rendererOptions: widget.options,
             dateValuesDictionary: pivotOptions ? pivotOptions.dateValuesDictionary : null,
-            keysObject: pivotOptions ? pivotOptions.keysObject : null,
         };
 
         if (!subopts.rendererOptions) {
@@ -7081,6 +7084,18 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 value_name: 'is_percentage',
                 default_value: false,
                 hidden: true,
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by variance',
+                value_name: 'sort_by_variance',
+                default_value: false,
+                hidden: true
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by absolute variance',
+                value_name: 'sort_by_absolute_variance',
+                default_value: false,
+                hidden: true
             }]
         },
         'delta_column_for_drill_down': {
@@ -7147,6 +7162,18 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 value_name: 'is_percentage',
                 default_value: false,
                 hidden: true,
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by variance',
+                value_name: 'sort_by_variance',
+                default_value: false,
+                hidden: true
+            }, {
+                element_type: 'checkbox',
+                element_label: 'Sort by absolute variance',
+                value_name: 'sort_by_absolute_variance',
+                default_value: false,
+                hidden: true
             }, {
                 element_type: 'checkbox',
                 element_label: 'Filter zero values',
@@ -8649,8 +8676,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
     };
 
     highchartsRenderer.getWidgetDataSorters = function (res, widget, defaultDateFormat) {
-        let sorters;
-
         if ($.pivotUtilities && !$.pivotUtilities.additionalFieldsList) {
             $.pivotUtilities.additionalFieldsList = [
                 {key: 'DR_Average', name: 'DR_Average'},
@@ -8658,19 +8683,30 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             ];
         }
 
-        let datesFields = [];
+        var datesFields = [];
         datesFields = lodash.filter(widget.rows, element => element.type == 'Date');
         datesFields = datesFields.concat(lodash.filter(widget.cols, element => element.type == 'Date'));
+
+        const isCustomSorting = widget.options.sortingFields && Array.isArray(widget.options.sortingFields) && widget.options.sortingFields.length > 0;
+        if (isCustomSorting) {
+            lodash.forEach(datesFields, function (field) {
+                const fieldToSort = lodash.find(widget.options.sortingFields, element => element.id === field.id);
+                field.sorting = fieldToSort ? fieldToSort.sorting : field.sorting;
+            });
+        }
+
         datesFields = lodash.map(datesFields, function (row) {
             return { "format": highchartsRenderer.getDateFieldFormat(widget, row), "name": row.name, "type": row.type, "values": [], "sorting": row.sorting } //'MMM - yyyy' format
         });
 
+        var data = res;
+
         lodash.forEach(datesFields, function (row) {
             row.val_not_convert = highchartsRenderer.check_values_not_for_convert(widget, row.name);
         });
 
         if (datesFields.length > 0) {
-            lodash.forEach(res, function (element) {
+            lodash.forEach(data, function (element) {
                 for (var i in datesFields) {
                     if (element.hasOwnProperty(datesFields[i].name)) {
                         datesFields[i].values.push(element[datesFields[i].name]);
@@ -8688,145 +8724,171 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                     }
                 }
             });
-
-            const invertedDateStringMap = lodash.invert(widget.pivot.dateValuesDictionary);
-            lodash.forEach([widget.pivot.keysObject.col_keys, widget.pivot.keysObject.row_keys], (widgetKeyLists, index) => {
-                const widgetFields = index ? widget.rows : widget.cols;
-                lodash.forEach(widgetKeyLists, keysList => {
-                    lodash.forEach(keysList, (key, index) => {
-                        if (widgetFields[index].type === 'Date') {
-                            keysList[index] = invertedDateStringMap[key] || key;
-                        }
-                    });
-                });
-            })
         }
+        lodash.forEach(datesFields, function (row) {
+            row.values = lodash.uniq(row.values);
 
-        if (!highchartsRenderer.isSortingOnBackendEnabled()) {
-            const isCustomSorting = widget.options.sortingFields && Array.isArray(widget.options.sortingFields) && widget.options.sortingFields.length > 0;
-            if (isCustomSorting) {
-                lodash.forEach(datesFields, function (field) {
-                    const fieldToSort = lodash.find(
-                        widget.options.sortingFields, element => element.id === field.id && lodash.get(element, 'sorting.sort_by') === 'field_items'
-                    );
-                    field.sorting = fieldToSort ? fieldToSort.sorting : field.sorting;
-                });
-            }
-    
-            lodash.forEach(datesFields, function (row) {
-                row.values = lodash.uniq(row.values);
-    
-                const isTimestampDateField = row.type === 'Date' && lodash.some(row.values, value => typeof value ==='number');
-                if (isTimestampDateField) {
-                    const nullValueIndex = row.values.indexOf(NULL_VALUE);
-                    if (~nullValueIndex) {
-                        row.values.splice(nullValueIndex, 1);
-                    }
-                    row.values = row.values.sort((a, b) => a - b);
-                    if (~nullValueIndex) {
-                        row.values.push(NULL_VALUE);
-                    }
-                } else {
-                    row.values = row.values.sort();
+            const isTimestampDateField = row.type === 'Date' && lodash.some(row.values, value => typeof value ==='number');
+            if (isTimestampDateField) {
+                const nullValueIndex = row.values.indexOf(NULL_VALUE);
+                if (~nullValueIndex) {
+                    row.values.splice(nullValueIndex, 1);
                 }
-    
-                if (row.sorting && row.sorting.type == "largestToSmallest") {
-                    row.values = lodash.reverse(row.values);
+                row.values = row.values.sort((a, b) => a - b);
+                if (~nullValueIndex) {
+                    row.values.push(NULL_VALUE);
                 }
-                delete row.sorting;
-                row.values = lodash.map(row.values, function (val) {
-                    return highchartsRenderer.returnRawDataValue(row.type, val, row.format, row.name, row.val_not_convert) + "";
-                })
-    
-            });
+            } else {
+                row.values = row.values.sort();
+            }
 
-            /* date string */
-            var rowsAndCols = [];
-            rowsAndCols = widget.rows.concat(widget.cols);
-
-            if (widget.chart_type === highchartsRenderer.CHART_TYPES.WATERFALL_BREAKDOWN) {
-
-                // if it is breakdown widget - redefine sorting according to breakdown_options
-                // TODO: remove this when BE sort will be implemented
-                lodash.forEach(rowsAndCols, function (field) {
-                    const waterfallFieldType = field.id === widget.cols[0].id ? 'totals' : 'breakdown';
-                    field.sorting = {
-                        type: 'CustomOrder',
-                        values: lodash.map(
-                            widget.options.breakdown_options.values[waterfallFieldType],
-                            value => value.key
-                        ),
-                    };
-                });
-            } else if (isCustomSorting) {
-                lodash.forEach(rowsAndCols, function (field) {
-                    const fieldToSort = lodash.find(
-                        widget.options.sortingFields, element => element.id === field.id && lodash.get(element, 'sorting.sort_by') === 'field_items'
-                    );
-                    field.sorting = fieldToSort ? fieldToSort.sorting : field.sorting;
-                });
+            if (row.sorting && row.sorting.type == "largestToSmallest") {
+                row.values = lodash.reverse(row.values);
             }
+            delete row.sorting;
+            row.values = lodash.map(row.values, function (val) {
+                return highchartsRenderer.returnRawDataValue(row.type, val, row.format, row.name, row.val_not_convert) + "";
+            })
+
+        });
+
+        /* date string */
+        var rowsAndCols = [];
+        rowsAndCols = widget.rows.concat(widget.cols);
+
+        if (widget.chart_type === highchartsRenderer.CHART_TYPES.WATERFALL_BREAKDOWN) {
 
+            // if it is breakdown widget - redefine sorting according to breakdown_options
+            // TODO: remove this when BE sort will be implemented
             lodash.forEach(rowsAndCols, function (field) {
-                if (field.sorting && (field.sorting.type == "DateString" || field.sorting.type == "largestToSmallest")) {
-                    var find_field = lodash.find(datesFields, {name: field.name});
-                    if (find_field) {
-                        if (find_field.type != 'Date')
-                            find_field.sorting = field.sorting;
-                    } else {
-                        datesFields.push({
-                            "format": field.format,
-                            "name": field.name,
-                            "type": field.type,
-                            "values": [],
-                            "sorting": field.sorting,
-                        });
-                    }
-                } else if (field.sorting && field.sorting.type == "CustomOrder" && field.sorting.values) {
+                const waterfallFieldType = field.id === widget.cols[0].id ? 'totals' : 'breakdown';
+                field.sorting = {
+                    type: 'CustomOrder',
+                    values: lodash.map(
+                        widget.options.breakdown_options.values[waterfallFieldType],
+                        value => value.key
+                    ),
+                };
+            });
+        } else if (isCustomSorting) {
+            lodash.forEach(rowsAndCols, function (field) {
+                const fieldToSort = lodash.find(widget.options.sortingFields, element => element.id === field.id);
+                field.sorting = fieldToSort ? fieldToSort.sorting : field.sorting;
+            });
+        }
+
+        lodash.forEach(rowsAndCols, function (field) {
+            if (field.sorting && (field.sorting.type == "DateString" || field.sorting.type == "largestToSmallest")) {
+                var find_field = lodash.find(datesFields, {name: field.name});
+                if (find_field) {
+                    if (find_field.type != 'Date')
+                        find_field.sorting = field.sorting;
+                } else {
                     datesFields.push({
                         "format": field.format,
                         "name": field.name,
                         "type": field.type,
-                        "values": field.sorting.values
+                        "values": [],
+                        "sorting": field.sorting,
                     });
                 }
+            } else if (field.sorting && field.sorting.type == "CustomOrder" && field.sorting.values) {
+                datesFields.push({
+                    "format": field.format,
+                    "name": field.name,
+                    "type": field.type,
+                    "values": field.sorting.values
+                });
+            }
+        });
+
+        if (widget.vals && widget.vals.length > 1) {
+            datesFields.push({name: "DR_Values", values: lodash.map(widget.vals, 'name')});
+        }
+
+        /****** END *******/
+
+        if (lodash.has(widget, "options.chartOptions.delta_column") &&
+            widget.options.chartOptions.delta_column.field != '' &&
+            (widget.options.chartOptions.delta_column.sort_by_variance ||
+                widget.options.chartOptions.delta_column.sort_by_absolute_variance) &&
+            widget.rows.length > 0 &&
+            widget.cols.length > 0 &&
+            widget.vals.length
+        ) {
+            let variance_config = widget.options.chartOptions.delta_column;
+            let val_field = widget.vals[0];
+            let field_for_sorting = null;
+            let field_with_variant = null;
+            if (variance_config.field == "series") {
+                field_for_sorting = widget.cols[0];
+                field_with_variant = widget.rows[0];
+            } else if (variance_config.field == "category") {
+                field_for_sorting = widget.rows[0];
+                field_with_variant = widget.cols[0];
+            }
+
+            let data_sorted = lodash.filter(data, function (data_row) {
+                return data_row[field_with_variant.name] == variance_config.name && data_row[field_for_sorting.name] != undefined;
             });
 
-            if (widget.vals && widget.vals.length > 1) {
-                datesFields.push({name: "DR_Values", values: lodash.map(widget.vals, 'name')});
+            const sorting_variance = widget.options.total_value_options && widget.options.total_value_options.sorting_variance === '' ? 'asc' : 'desc';
+
+            if (widget.options.chartOptions.delta_column.sort_by_absolute_variance) {
+                data_sorted = lodash.sortBy(data_sorted, function (o) {
+                    if (sorting_variance === 'desc') {
+                        return Math.abs(o[val_field.name]) * -1;
+                    }
+
+                    return Math.abs(o[val_field.name]) * 1;
+                });
+            } else {
+                data_sorted = lodash.orderBy(data_sorted, [val_field.name], [sorting_variance]);
             }
-    
-            /****** END *******/
-            
-            // TODO: Remove. sortingValues looks like lagacy which is not in use neither in webclient nor in renderer
-            if (widget.options && widget.options.sortingValues) {
-                var field = lodash.find(datesFields, {name: widget.options.sortingValues.field});
+
+            let values_for_sort = lodash.map(data_sorted, function (data_row) {
+                return data_row[field_for_sorting.name];
+            });
+
+            values_for_sort = lodash.uniq(values_for_sort);
+
+            if (values_for_sort.length > 0) {
+                let field = lodash.find(datesFields, {name: field_for_sorting.name});
                 if (field) {
-                    field.values = widget.options.sortingValues.values;
+                    field.values = values_for_sort;
                     field.sorting = null;
                 } else {
-                    datesFields.push({
-                        name: widget.options.sortingValues.field,
-                        values: widget.options.sortingValues.values
-                    });
+                    datesFields.push({name: field_for_sorting.name, values: values_for_sort});
                 }
             }
-            sorters = function (attr) {
-                var field = lodash.find(datesFields, {name: attr});
-                if (field)
-                    if (field.sorting && field.sorting.type == "DateString") {
-                        return $.pivotUtilities.sortDateStrings(field.sorting.month_order);
-                    } else if (field.sorting && field.sorting.type == "largestToSmallest") {
-                        if (field.sorting.is_absolute)
-                            return $.pivotUtilities.largeToSmallSortByAbsolute;
-    
-                        return $.pivotUtilities.largeToSmallSort;
-                    } else {
-                        return $.pivotUtilities.sortAs(field.values);
-                    }
-            };
+        } else if (widget.options && widget.options.sortingValues) {
+            var field = lodash.find(datesFields, {name: widget.options.sortingValues.field});
+            if (field) {
+                field.values = widget.options.sortingValues.values;
+                field.sorting = null;
+            } else {
+                datesFields.push({
+                    name: widget.options.sortingValues.field,
+                    values: widget.options.sortingValues.values
+                });
+            }
         }
 
+        let sorters = function (attr) {
+            var field = lodash.find(datesFields, {name: attr});
+            if (field)
+                if (field.sorting && field.sorting.type == "DateString") {
+                    return $.pivotUtilities.sortDateStrings(field.sorting.month_order);
+                } else if (field.sorting && field.sorting.type == "largestToSmallest") {
+                    if (field.sorting.is_absolute)
+                        return $.pivotUtilities.largeToSmallSortByAbsolute;
+
+                    return $.pivotUtilities.largeToSmallSort;
+                } else {
+                    return $.pivotUtilities.sortAs(field.values);
+                }
+        };
+
         return sorters;
     };
 
@@ -8845,12 +8907,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
 
     //highchartsRenderer.getGraphOptions(scope.data, override_values, res, scope.dataModel.templatesWithOutData, scope.openDrillDownList, drillDownFunction)
     highchartsRenderer.getGraphOptions = function (widget_obj, override_values, row_data, templates, openDrillDownListFunction, drillDownFunction) {
-
-        let keysObject;
-        if (highchartsRenderer.isSortingOnBackendEnabled()) {
-            keysObject = row_data.pop();
-        }
-
         let res = highchartsRenderer.updateSelectedOverrideValues(widget_obj, override_values, row_data);
         res = highchartsRenderer.convertUniqueDateValues(widget_obj, templates, res);
 
@@ -8862,10 +8918,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
 
         let pivot = {};
 
-        if (highchartsRenderer.isSortingOnBackendEnabled()) {
-            pivot.keysObject = keysObject;
-        }
-
         let templateNoData = lodash.find(templates, {id: widget_obj.template_id});
         if (templateNoData) {
 
@@ -8902,8 +8954,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             subopts.onlyOptions = true;
         }
 
-        subopts.keysObject = keysObject;
-
         let hc_options = highchartsRenderer.rhPivotView(res, subopts, is_table, widget_obj);
 
         return hc_options;
@@ -9231,10 +9281,6 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         }
     }
 
-    highchartsRenderer.isSortingOnBackendEnabled = function() {
-        return lodash.includes(lodash.get(document, 'ReportHippo.user.features'), 'enable_server_widget_data_sorting');
-    }
-
     return highchartsRenderer;
 };