@datarailsshared/dr_renderer 1.2.369 → 1.2.371

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datarailsshared/dr_renderer",
-  "version": "1.2.369",
+  "version": "1.2.371",
   "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
@@ -8860,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;
@@ -8900,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) {
@@ -8924,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'))) {
@@ -8980,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)
@@ -9088,7 +9100,7 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
 
         let keysObject;
         if (highchartsRenderer.isSortingOnBackendEnabled) {
-            keysObject = row_data.pop();
+            keysObject = highchartsRenderer.getAggregatedSortingObjects(row_data);
         }
 
         let res = highchartsRenderer.updateSelectedOverrideValues(widget_obj, override_values, row_data);
@@ -9688,6 +9700,30 @@ let getHighchartsRenderer = function ($, document, Highcharts, default_colors, h
         return res;
     }
 
+    // TODO: move this logic to BE (the problem it is solving that BE returns several sorting objects for more than 1 field in Values)
+    highchartsRenderer.getAggregatedSortingObjects = function(res) {
+        let sortingObjectToReturn = null;
+
+        lodash.forEach(res, (dataRow) => {
+            if (!lodash.isNil(dataRow.row_keys) || !lodash.isNil(dataRow.col_keys)) {
+                if (!sortingObjectToReturn) {
+                    sortingObjectToReturn = Object.assign({}, dataRow);
+                } else {
+                    sortingObjectToReturn.row_keys = lodash.concat(sortingObjectToReturn.row_keys, dataRow.row_keys || []);
+                }
+                dataRow.isSortingObject = true;
+            }
+        });
+
+        if (sortingObjectToReturn) {
+            const resWithoutSortObjects = lodash.filter(res, (dataRow) => !dataRow.isSortingObject);
+            res.length = 0;
+            Object.assign(res, resWithoutSortObjects);
+        }
+
+        return sortingObjectToReturn;
+    }
+
     return highchartsRenderer;
 };
 

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,192 @@ 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);
+        });
+    });
+    
+
+    describe('Functions getAggregatedSortingObjects', () => {
+
+        const simpleRowData = [{ someField1: 'someValue1' }, { someField2: 'someValue2' }];
+
+        const generalTestCases = [
+            {
+                description: 'should get sort object and remove from data rows (case with all fields)',
+                expectedObj:  { col_keys: ['colKey1', 'colKey2'], row_keys: ['rowKey1', 'rowKey2'], row_keys_by_cols: [['1', '2'], ['2', '1']] },
+            },
+            {
+                description: 'should get sort object and remove from data rows (case with only colkeys)',
+                expectedObj:  { row_keys: [], col_keys: ['colKey1', 'colKey2'] },
+            },
+            {
+                description: 'should get sort object and remove from data rows (case with only rowkeys)',
+                expectedObj:  { row_keys: ['rowKey1', 'rowKey2'], col_keys: [] },
+            },
+            {
+                description: 'should get null sort object and remove from data rows (case with no sorting object)',
+                expectedObj: null,
+            }
+        ];
+
+        lodash.forEach(generalTestCases, testCase => {
+            it(testCase.description, () => {
+                const rowData = lodash.concat(simpleRowData, testCase.expectedObj ? lodash.clone(testCase.expectedObj) : []);
+                const sortObj = highchartsRenderer.getAggregatedSortingObjects(rowData);
+    
+                expect(rowData).toEqual(simpleRowData);
+                expect(sortObj).toEqual(testCase.expectedObj);
+            });
+        });
+
+        it('should get sort object and remove from data rows (several object encounters - for more than one Values field)', () => {
+
+            const expectedObj = { col_keys: ['colKey1', 'colKey2'], row_keys: ['rowKey1', 'rowKey2'] };
+            const rowData = [
+                { someField1: 'someValue1' },
+                { col_keys: ['colKey1', 'colKey2'], row_keys: ['rowKey1'] },
+                { someField2: 'someValue2' },
+                { someField3: 'someValue3' },
+                { someField4: 'someValue4' },
+                { col_keys: ['colKey1', 'colKey2'], row_keys: ['rowKey2'] },
+            ];
+
+            const sortObj = highchartsRenderer.getAggregatedSortingObjects(rowData);
+
+            expect(rowData).toEqual([
+                { someField1: 'someValue1' },
+                { someField2: 'someValue2' },
+                { someField3: 'someValue3' },
+                { someField4: 'someValue4' },
+            ]);
+            expect(sortObj).toEqual(expectedObj);
+        });
+    });
 });