Merge pull request #10647 from IgniteUI/skrastev/fix-10639

[igxPivot] Ensure that bottom level dimensions get populated regardless of expansion.

Author: dkamburov

projects/igniteui-angular/src/lib/data-operations/pivot-strategy.ts

@@ -28,47 +28,58 @@ export class PivotRowDimensionsStrategy implements IPivotDimensionStrategy {
     }
 
     public process(
-            collection: any,
-            rows: IPivotDimension[],
-            values?: IPivotValue[],
-            pivotKeys: IPivotKeys =
-            { aggregations: 'aggregations', records: 'records', children: 'children', level: 'level'}
-        ): any[] {
-            let hierarchies;
-            let data;
-            const prevRowDims = [];
-            let prevDim;
-            const currRows = cloneArray(rows, true);
-            PivotUtil.assignLevels(currRows);
-            for (const row of currRows) {
-                if (!data) {
-                    // build hierarchies - groups and subgroups
-                    hierarchies = PivotUtil.getFieldsHierarchy(collection, [row], PivotDimensionType.Row, pivotKeys);
-                    // generate flat data from the hierarchies
-                    data = PivotUtil.processHierarchy(hierarchies, collection[0] ?? [], pivotKeys, 0, true);
-                    prevRowDims.push(row);
-                    prevDim = row;
-                } else {
-                    const newData = [...data];
-                    for (let i = 0; i < newData.length; i++) {
-                        const currData = newData[i][prevDim.memberName + '_' + pivotKeys.records];
-                        const leafData = PivotUtil.getDirectLeafs(currData, pivotKeys);
-                        const hierarchyFields = PivotUtil
-                            .getFieldsHierarchy(leafData, [row], PivotDimensionType.Row, pivotKeys);
-                        const siblingData = PivotUtil
-                            .processHierarchy(hierarchyFields, newData[i] ?? [], pivotKeys, 0);
-                        PivotUtil.processSiblingProperties(newData[i], siblingData, pivotKeys);
+        collection: any,
+        rows: IPivotDimension[],
+        values?: IPivotValue[],
+        pivotKeys: IPivotKeys =
+            { aggregations: 'aggregations', records: 'records', children: 'children', level: 'level' }
+    ): any[] {
+        let hierarchies;
+        let data;
+        const prevRowDims = [];
+        let prevDim;
+        let prevDimTopRecords = [];
+        const currRows = cloneArray(rows, true);
+        PivotUtil.assignLevels(currRows);
+        for (const row of currRows) {
+            if (!data) {
+                // build hierarchies - groups and subgroups
+                hierarchies = PivotUtil.getFieldsHierarchy(collection, [row], PivotDimensionType.Row, pivotKeys);
+                // generate flat data from the hierarchies
+                data = PivotUtil.processHierarchy(hierarchies, collection[0] ?? [], pivotKeys, 0, true);
+                prevRowDims.push(row);
+                prevDim = row;
+                prevDimTopRecords = data;
+            } else {
+                const newData = [...data];
+                const curDimTopRecords = [];
+                for (let i = 0; i < newData.length; i++) {
+                    const currData = newData[i][prevDim.memberName + '_' + pivotKeys.records];
+                    const leafData = PivotUtil.getDirectLeafs(currData, pivotKeys);
+                    const hierarchyFields = PivotUtil
+                        .getFieldsHierarchy(leafData, [row], PivotDimensionType.Row, pivotKeys);
+                    const siblingData = PivotUtil
+                        .processHierarchy(hierarchyFields, newData[i] ?? [], pivotKeys, 0);
+                    PivotUtil.processSiblingProperties(newData[i], siblingData, pivotKeys);
 
                     PivotUtil.processSubGroups(row, prevRowDims.slice(0), siblingData, pivotKeys);
-                    if (PivotUtil.getDimensionDepth(prevDim) > PivotUtil.getDimensionDepth(row) && siblingData.length > 1) {
+                    if ((prevDimTopRecords[i].length != undefined && prevDimTopRecords[i].length < siblingData.length) || prevDimTopRecords.length < siblingData.length) {
+                        // Add the sibling data as child records because the previous dimension contains more dense version of the previous dimension records.
                         newData[i][row.memberName + '_' + pivotKeys.records] = siblingData;
                     } else {
+                        // Replace the current record with the sibling records because the current dimension is a denser version or produces the same amount of records.
                         newData.splice(i, 1, ...siblingData);
+                        // Shift the prevDimTopRecords item to the right because of the previous row transforms the newData and increases the elements in newData
+                        prevDimTopRecords.splice(siblingData.length, prevDimTopRecords.length - siblingData.length, ...prevDimTopRecords);
+                        // Increase the index the amount of sibling record that replaces the current one. Subtract 1 because there is already i++ in the for cycle.
                         i += siblingData.length - 1;
                     }
+                    // Add the current top sibling elements for the dimension
+                    curDimTopRecords.push(cloneArray(siblingData, true));
                 }
                 data = newData;
                 prevDim = row;
+                prevDimTopRecords = curDimTopRecords;
                 prevRowDims.push(row);
             }
         }

projects/igniteui-angular/src/lib/grids/pivot-grid/pivot-grid.pipes.ts

@@ -66,7 +66,7 @@ export class IgxPivotRowExpansionPipe implements PipeTransform {
         for (const row of enabledRows) {
             const lvl = PivotUtil.getDimensionDepth(row);
             totalLlv += lvl;
-            PivotUtil.flattenHierarchy(data, config, row, expansionStates, defaultExpand, pivotKeys, totalLlv, prevDims, 0);
+            PivotUtil.flattenHierarchy(data, config, row, expansionStates, defaultExpand, pivotKeys, totalLlv, prevDims, 0, lvl);
             prevDims.push(row);
         }
         const finalData = config.columnStrategy ? data : data.filter(x => x[pivotKeys.records]);

projects/igniteui-angular/src/lib/grids/pivot-grid/pivot-util.ts

@@ -82,7 +82,8 @@ export class PivotUtil {
         pivotKeys: IPivotKeys,
         lvl: number,
         prevDims: IPivotDimension[],
-        currDimLvl: number) {
+        currDimLvl: number,
+        maxDimLvl: number) {
         const data = records;
         for (let i = 0; i < data.length; i++) {
             const rec = data[i];
@@ -97,12 +98,12 @@ export class PivotUtil {
                 expansionStates.get(expansionRowKey);
             if (rec[field + '_' + pivotKeys.records] &&
                 rec[field + '_' + pivotKeys.records].length > 0 &&
-                isExpanded && lvl > 0) {
+                ((isExpanded && lvl > 0)  || (maxDimLvl == currDimLvl))) {
                 let dimData = rec[field + '_' + pivotKeys.records];
                 if (dim.childLevel) {
                     if (PivotUtil.getDimensionDepth(dim) > 1) {
                         dimData = this.flattenHierarchy(dimData, config, dim.childLevel,
-                            expansionStates, defaultExpandState, pivotKeys, lvl - 1, prevDims, currDimLvl + 1);
+                            expansionStates, defaultExpandState, pivotKeys, lvl - 1, prevDims, currDimLvl + 1, maxDimLvl);
                     } else {
                         dimData.forEach(d => {
                             d[dim.childLevel.memberName + '_' + pivotKeys.level] = currDimLvl + 1;