@datarailsshared/dr_renderer 1.2.368 → 1.2.370

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datarailsshared/dr_renderer",
-  "version": "1.2.368",
+  "version": "1.2.370",
   "description": "DataRails charts and tables renderer",
   "keywords": [
     "datarails",

package/src/highcharts_renderer.js

@@ -1547,7 +1547,7 @@ 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;
+        const rows_by_cols = pivotData.getRowKeysByCols();
 
         let resultObject = {
             data: [],
@@ -3584,7 +3584,9 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             ? opts.chartOptions
             : highchartsRenderer.getDefaultValueForChart(highchartsRenderer.CHART_TYPES.WATERFALL_BREAKDOWN);
 
-        pivotData.colKeys = lodash.map(lodash.keys(pivotData.colTotals), key => [key]);
+        if (!highchartsRenderer.isSortingOnBackendEnabled) {
+            pivotData.colKeys = lodash.map(lodash.keys(pivotData.colTotals), key => [key]);
+        }
 
         chartOptions.chart = {
             type: 'waterfall',
@@ -5412,6 +5414,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         widgetOptions.pivot.chartOptions = widgetOptions.options;
         widgetOptions.pivot.chartRender = highchartsRenderer.getChartRendererFunction(widgetOptions.pivot.chartType, drilldownFunc, drillDownListFunc, insightsTooltipFunc, trackUserInsightsTooltipFunc);
 
+        if (highchartsRenderer.isSortingOnBackendEnabled) return;
         // TODO: remove this logic after BE sort is implemented
         // it is required to do sort by totals for comparative analysis - we need to change deltas if columns swaped vice versa
         const isTwoColumnComparisonWidget = widgetOptions.chart_type === highchartsRenderer.CHART_TYPES.WATERFALL_BREAKDOWN
@@ -6548,25 +6551,29 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 element_type: 'input',
                 value_name: 'low',
                 element_label: 'Low %',
-                default_value: 10
+                default_value: 10,
+                value_type: 'number'
             },
                 {
                     element_type: 'input',
                     value_name: 'medium',
                     element_label: 'Medium %',
-                    default_value: 50
+                    default_value: 50,
+                    value_type: 'number'
                 },
                 {
                     element_type: 'input',
                     value_name: 'high',
                     element_label: 'High %',
-                    default_value: 90
+                    default_value: 90,
+                    value_type: 'number'
                 },
                 {
                     element_type: 'input',
                     value_name: 'max',
                     element_label: 'Max',
-                    default_value: 1000
+                    default_value: 1000,
+                    value_type: 'number'
                 }
             ]
         },
@@ -8856,6 +8863,25 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         return res;
     };
 
+    highchartsRenderer.replaceSortingKeysWithMappedValues = function(keys, invertedDateStringMap, widgetFields) {
+        if (!keys || !invertedDateStringMap) {
+            return;
+        }
+        const replaceNestedKeys = (nestedKeys) => {
+            for (let i = 0; i < nestedKeys.length; i++) {
+                if (Array.isArray(nestedKeys[i])) {
+                    replaceNestedKeys(nestedKeys[i]);
+                } else if (invertedDateStringMap[nestedKeys[i]] && widgetFields[i] && widgetFields[i].type === 'Date') {
+                    nestedKeys[i] = invertedDateStringMap[nestedKeys[i]];
+                }
+            }
+        };
+    
+        for (let i = 0; i < keys.length; i++) {
+            replaceNestedKeys(keys[i]);
+        }
+    }
+
     highchartsRenderer.getWidgetDataSorters = function (res, widget, defaultDateFormat) {
         const isFormattingDatesAsOtherAxisTypes = highchartsRenderer.isFormattingDatesAsOtherAxisTypes();
         let sorters;
@@ -8896,7 +8922,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                 row.val_not_convert = highchartsRenderer.check_values_not_for_convert(widget, row.name);
             });
         }
-    
+
         if (datesFields.length > 0) {
             const invertedDateStringMap = {};
             lodash.forEach(res, function (element) {
@@ -8920,25 +8946,15 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
                         }
                     }
                 }
-            });
+                if (highchartsRenderer.sortHasBeenDoneOnBE(lodash.get(widget, 'pivot.keysObject')) && !isFormattingDatesAsOtherAxisTypes) {
+                    const keysObject = lodash.get(widget, 'pivot.keysObject');
 
-            if (highchartsRenderer.sortHasBeenDoneOnBE(lodash.get(widget, 'pivot.keysObject')) && !isFormattingDatesAsOtherAxisTypes) {
-                lodash.forEach(['col_keys', 'row_keys'], (keysListName, index) => {
-                    const widgetFields = index ? widget.rows : widget.cols;
-                    const uniqueFormattedKeysList = [];
-                    lodash.forEach(widget.pivot.keysObject[keysListName], subKeysList => {
-                        lodash.forEach(subKeysList, (key, index) => {
-                            if (widgetFields[index] && widgetFields[index].type === 'Date') {
-                                subKeysList[index] = invertedDateStringMap[key] || key;
-                            }
-                        });
-                        if (!lodash.find(uniqueFormattedKeysList, formattedSubKeys => lodash.isEqual(formattedSubKeys, subKeysList))) {
-                            uniqueFormattedKeysList.push(subKeysList);
-                        }
+                    lodash.forEach(['col_keys', 'row_keys', 'row_keys_by_cols'], (keysListName) => {
+                        const widgetFields = keysListName === 'col_keys' ? widget.cols : widget.rows;
+                        highchartsRenderer.replaceSortingKeysWithMappedValues(lodash.get(keysObject, keysListName), invertedDateStringMap, widgetFields);
                     });
-                    widget.pivot.keysObject[keysListName] = uniqueFormattedKeysList;
-                });
-            }
+                }
+            });
         }
 
         if (!highchartsRenderer.sortHasBeenDoneOnBE(lodash.get(widget, 'pivot.keysObject'))) {
@@ -8976,7 +8992,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
             var rowsAndCols = [];
             rowsAndCols = widget.rows.concat(widget.cols);
 
-            if (widget.chart_type === highchartsRenderer.CHART_TYPES.WATERFALL_BREAKDOWN) {
+            if (widget.chart_type === highchartsRenderer.CHART_TYPES.WATERFALL_BREAKDOWN && !highchartsRenderer.sortHasBeenDoneOnBE(lodash.get(widget, 'pivot.keysObject'))) {
 
                 // if it is breakdown widget - redefine sorting according to breakdown_options
                 // TODO: remove this when BE sort will be implemented (FE subtickets for story DR-18469)

package/src/pivottable.js

@@ -671,6 +671,7 @@ let initPivotTable = function($, window, document) {
             this.getAggregator = bind(this.getAggregator, this);
             this.getRowKeys = bind(this.getRowKeys, this);
             this.getColKeys = bind(this.getColKeys, this);
+            this.getRowKeysByCols = bind(this.getRowKeysByCols, this);
             this.sortKeys = bind(this.sortKeys, this);
             this.arrSort = bind(this.arrSort, this);
             this.input = input;
@@ -693,7 +694,7 @@ let initPivotTable = function($, window, document) {
             if (this.isKeysSortingDoneOnBackendSide) {
                 this.rowKeys = opts.keysObject.row_keys;
                 this.colKeys = opts.keysObject.col_keys;
-                // TODO: add also for breakdown sort object when BE story is ready.
+                this.rowKeysByCols = opts.keysObject.row_keys_by_cols;
             } else {
                 this.rowKeys = [];
                 this.colKeys = [];
@@ -883,6 +884,10 @@ let initPivotTable = function($, window, document) {
             return this.rowKeys;
         };
 
+        PivotData.prototype.getRowKeysByCols = function() {
+            return this.rowKeysByCols;
+        };
+
         PivotData.prototype.processRecord = function(record) {
             var colKey, flatColKey, flatRowKey, l, len1, len2, n, ref, ref1, ref2, ref3, rowKey, x;
             colKey = [];

package/tests/highcharts_renderer.test.js

@@ -5521,4 +5521,134 @@ describe('highcharts_renderer', () => {
             expect(highchartsRenderer.getColsInFormatterContext(context, pivotData)).toEqual(name2);
         });
     });
+
+
+    describe('Function replaceSortingKeysWithMappedValues', () => {
+        it('should replace sorting keys with mapped values for Date fields', () => {
+            const keysObject = {
+                col_keys: [
+                    [1640995200],
+                    [1648684800],
+                    [1667174400]
+                ],
+                row_keys: [],
+                row_keys_by_cols: [
+                    [
+                        ["Other Income"],
+                        ["Other Expense"],
+                        ["Income"],
+                        ["Expenses"],
+                        ["Cost of Goods Sold"]
+                    ]
+                ]
+            };
+            const invertedDateStringMap = {
+                1640995200: '2022-01-01',
+                1648684800: '2022-03-29',
+                1667174400: '2023-03-01'
+            };
+            const widget = {
+                cols: [{ type: 'Date' }],
+                rows: [{ type: 'NotDate' }],
+                pivot: {
+                    keysObject: keysObject
+                }
+            };
+    
+            highchartsRenderer.replaceSortingKeysWithMappedValues(keysObject.col_keys, invertedDateStringMap, widget.cols);
+            highchartsRenderer.replaceSortingKeysWithMappedValues(keysObject.row_keys, invertedDateStringMap, widget.rows);
+            highchartsRenderer.replaceSortingKeysWithMappedValues(keysObject.row_keys_by_cols, invertedDateStringMap, widget.rows);
+    
+            expect(keysObject).toEqual({
+                col_keys: [
+                    ['2022-01-01'],
+                    ['2022-03-29'],
+                    ['2023-03-01']
+                ],
+                row_keys: [],
+                row_keys_by_cols: [
+                    [
+                        ['Other Income'],
+                        ['Other Expense'],
+                        ['Income'],
+                        ['Expenses'],
+                        ['Cost of Goods Sold']
+                    ]
+                ]
+            });
+        });
+    
+        it('should not replace sorting keys for non-Date fields', () => {
+            const keysObject = {
+                col_keys: [
+                    [1640995200],
+                    [1648684800],
+                    [1667174400]
+                ],
+                row_keys: [],
+                row_keys_by_cols: [
+                    [
+                        ["Other Income"],
+                        ["Other Expense"],
+                        ["Income"],
+                        ["Expenses"],
+                        ["Cost of Goods Sold"]
+                    ]
+                ]
+            };
+            const invertedDateStringMap = {
+                1640995200: '2022-01-01',
+                1648684800: '2022-03-29',
+                1667174400: '2023-03-01'
+            };
+            const widget = {
+                cols: [{ type: 'NotDate' }],
+                rows: [{ type: 'NotDate' }],
+                pivot: {
+                    keysObject: keysObject
+                }
+            };
+    
+            highchartsRenderer.replaceSortingKeysWithMappedValues(keysObject.col_keys, invertedDateStringMap, widget.cols);
+            highchartsRenderer.replaceSortingKeysWithMappedValues(keysObject.row_keys, invertedDateStringMap, widget.rows);
+            highchartsRenderer.replaceSortingKeysWithMappedValues(keysObject.row_keys_by_cols, invertedDateStringMap, widget.rows);
+    
+            expect(keysObject).toEqual({
+                col_keys: [
+                    [1640995200],
+                    [1648684800],
+                    [1667174400]
+                ],
+                row_keys: [],
+                row_keys_by_cols: [
+                    [
+                        ["Other Income"],
+                        ["Other Expense"],
+                        ["Income"],
+                        ["Expenses"],
+                        ["Cost of Goods Sold"]
+                    ]
+                ]
+            });
+        });
+    
+        it('should handle null or undefined keysObject', () => {
+            const invertedDateStringMap = {
+                1640995200: '2022-01-01',
+                1648684800: '2022-03-29',
+                1667174400: '2023-03-01'
+            };
+            const widget = {
+                cols: [{ type: 'Date' }],
+                rows: [{ type: 'NotDate' }],
+                pivot: {
+                    keysObject: null
+                }
+            };
+    
+            highchartsRenderer.replaceSortingKeysWithMappedValues(null, invertedDateStringMap, widget.cols);
+            highchartsRenderer.replaceSortingKeysWithMappedValues(null, invertedDateStringMap, widget.rows);
+            highchartsRenderer.replaceSortingKeysWithMappedValues(null, invertedDateStringMap, widget.rows);
+        });
+    });
 });