@easyquery/enterprise 7.2.3-rc03 → 7.2.4-beta03

package/dist/lib/data/data_table_aggr_calculator.d.ts

@@ -1,47 +1,47 @@
-import { AggregatesCalculator, AggregatesContainer, AggrCalculationOptions, DataRow } from '@easydata/core';
-import { EqContext } from '@easyquery/core';
-interface ColumnAggregates {
-    sum: number;
-    min: number;
-    max: number;
-}
-interface ColumnsWithAggregates {
-    [columnId: string]: ColumnAggregates;
-}
-interface RowAggregates {
-    count: number;
-    columns: ColumnsWithAggregates;
-}
-export declare class DataTableAggregatesCalculator implements AggregatesCalculator {
-    protected context: EqContext;
-    private aggrContainer;
-    private aggrSettings;
-    private groups;
-    private aggregates;
-    private aggrColIds;
-    private aggrCols;
-    private levelsTotals;
-    constructor(context: EqContext);
-    getAggrContainer(): AggregatesContainer;
-    protected initObjects(): void;
-    private createColumnAggregatesObject;
-    calculate(options?: AggrCalculationOptions): Promise<void>;
-    protected resetLevelTotals(rowTotals: RowAggregates): void;
-    private prevRow;
-    protected processDataRow(row: DataRow): void;
-    /** Checks if the values in group columns were changed
-        and return the level number they were */
-    protected checkLevelChange(row: DataRow): number;
-    /** Saves the current values in levelData for the specified level to AggregateContainer
-        and then reset the data row for that level
-    */
-    protected flushLevelTotals(levelIndex: number): void;
-    protected applyAggrFunc(funcId: string, columnTotals: ColumnAggregates, levelTotals: RowAggregates): Number;
-    /** Updates the totals by values in the current DataRow
-     * and according to the specified aggregate
-    */
-    protected updateLevelTotals(levelIndex: number, row: DataRow): void;
-    needRecalculation(): boolean;
-    reset(): void;
-}
-export {};
+import { AggregatesCalculator, AggregatesContainer, AggrCalculationOptions, DataRow } from '@easydata/core';
+import { EqContext } from '@easyquery/core';
+interface ColumnAggregates {
+    sum: number;
+    min: number;
+    max: number;
+}
+interface ColumnsWithAggregates {
+    [columnId: string]: ColumnAggregates;
+}
+interface RowAggregates {
+    count: number;
+    columns: ColumnsWithAggregates;
+}
+export declare class DataTableAggregatesCalculator implements AggregatesCalculator {
+    protected context: EqContext;
+    private aggrContainer;
+    private aggrSettings;
+    private groups;
+    private aggregates;
+    private aggrColIds;
+    private aggrCols;
+    private levelsTotals;
+    constructor(context: EqContext);
+    getAggrContainer(): AggregatesContainer;
+    protected initObjects(): void;
+    private createColumnAggregatesObject;
+    calculate(options?: AggrCalculationOptions): Promise<void>;
+    protected resetLevelTotals(rowTotals: RowAggregates): void;
+    private prevRow;
+    protected processDataRow(row: DataRow): void;
+    /** Checks if the values in group columns were changed
+        and return the level number they were */
+    protected checkLevelChange(row: DataRow): number;
+    /** Saves the current values in levelData for the specified level to AggregateContainer
+        and then reset the data row for that level
+    */
+    protected flushLevelTotals(levelIndex: number): void;
+    protected applyAggrFunc(funcId: string, columnTotals: ColumnAggregates, levelTotals: RowAggregates): Number;
+    /** Updates the totals by values in the current DataRow
+     * and according to the specified aggregate
+    */
+    protected updateLevelTotals(levelIndex: number, row: DataRow): void;
+    needRecalculation(): boolean;
+    reset(): void;
+}
+export {};

package/dist/lib/data/data_table_aggr_calculator.js

@@ -1,164 +1,164 @@
-import { EqAggregatesContainer } from '@easyquery/core';
-var DataTableAggregatesCalculator = /** @class */ (function () {
-    function DataTableAggregatesCalculator(context) {
-        this.context = context;
-        //stores current totals by level (group) number
-        this.levelsTotals = [];
-        this.prevRow = null;
-        this.aggrContainer = new EqAggregatesContainer(context);
-    }
-    DataTableAggregatesCalculator.prototype.getAggrContainer = function () {
-        return this.aggrContainer;
-    };
-    DataTableAggregatesCalculator.prototype.initObjects = function () {
-        var _this = this;
-        this.aggrSettings = this.context.getQuery().getAggregationSettings();
-        this.groups = this.aggrSettings.getGroups();
-        this.aggregates = this.aggrSettings.getAggregates();
-        this.aggrColIds = this.aggrSettings.getAggregates().map(function (a) { return a.colId; });
-        this.aggrCols = this.context.resultTable.columns.getItems()
-            .filter(function (col) { return _this.aggrColIds.indexOf(col.id) >= 0; });
-        this.levelsTotals = [];
-        this.prevRow = null;
-    };
-    DataTableAggregatesCalculator.prototype.createColumnAggregatesObject = function () {
-        return {
-            sum: 0,
-            min: Number.MAX_VALUE,
-            max: Number.MIN_VALUE
-        };
-    };
-    DataTableAggregatesCalculator.prototype.calculate = function (options) {
-        this.initObjects();
-        this.aggrContainer.clear();
-        options = options || {};
-        options.maxLevel = options.maxLevel >= 0
-            ? options.maxLevel : 0;
-        var levelNumber = this.groups.length + 1; //number of groups plus grand totals
-        for (var levelIndex = 0; levelIndex < levelNumber; levelIndex++) {
-            var levelTotals = { count: 0, columns: {} };
-            this.resetLevelTotals(levelTotals);
-            this.levelsTotals.push(levelTotals);
-        }
-        var allRows = this.context.resultTable.getCachedRows();
-        if (allRows.length > 0) {
-            for (var _i = 0, allRows_1 = allRows; _i < allRows_1.length; _i++) {
-                var row = allRows_1[_i];
-                this.processDataRow(row);
-            }
-            //flusing the totals for all group levels
-            for (var levelIndex = 1; levelIndex < levelNumber; levelIndex++) {
-                this.flushLevelTotals(levelIndex);
-            }
-            //flusing the grand totals (if they are turned on)
-            if (this.aggrSettings.hasGrandTotals()) {
-                this.flushLevelTotals(0);
-            }
-        }
-        return Promise.resolve();
-    };
-    DataTableAggregatesCalculator.prototype.resetLevelTotals = function (rowTotals) {
-        for (var _i = 0, _a = this.aggrCols; _i < _a.length; _i++) {
-            var aggrCol = _a[_i];
-            rowTotals.columns[aggrCol.id] = this.createColumnAggregatesObject();
-        }
-        rowTotals.count = 0;
-    };
-    DataTableAggregatesCalculator.prototype.processDataRow = function (row) {
-        var levelIndexChanged = this.checkLevelChange(row);
-        if (levelIndexChanged >= 0) {
-            for (var levelIndex_1 = levelIndexChanged; levelIndex_1 < this.levelsTotals.length; levelIndex_1++) {
-                this.flushLevelTotals(levelIndex_1);
-            }
-        }
-        if (this.aggrSettings.hasGrandTotals()) {
-            this.updateLevelTotals(0, row);
-        }
-        var levelIndex = 1;
-        for (var _i = 0, _a = this.groups; _i < _a.length; _i++) {
-            var group = _a[_i];
-            this.updateLevelTotals(levelIndex, row);
-            levelIndex++;
-        }
-        this.prevRow = row;
-    };
-    /** Checks if the values in group columns were changed
-        and return the level number they were */
-    DataTableAggregatesCalculator.prototype.checkLevelChange = function (row) {
-        if (this.prevRow == null)
-            return -1;
-        for (var groupIndex = 0; groupIndex < this.groups.length; groupIndex++) {
-            var group = this.groups[groupIndex];
-            for (var _i = 0, _a = group.columns; _i < _a.length; _i++) {
-                var colId = _a[_i];
-                var value = row.getValue(colId);
-                var prevValue = this.prevRow.getValue(colId);
-                if (!this.aggrSettings.compareValues(prevValue, value)) {
-                    return groupIndex + 1;
-                }
-            }
-        }
-        return -1;
-    };
-    /** Saves the current values in levelData for the specified level to AggregateContainer
-        and then reset the data row for that level
-    */
-    DataTableAggregatesCalculator.prototype.flushLevelTotals = function (levelIndex) {
-        var levelTotals = this.levelsTotals[levelIndex];
-        var group = levelIndex > 0 ? this.groups[levelIndex - 1] : null;
-        var groupKey = this.aggrSettings.buildGroupKey(group, this.prevRow);
-        var groupTotals = {};
-        for (var _i = 0, _a = this.aggregates; _i < _a.length; _i++) {
-            var aggr = _a[_i];
-            var columnTotals = levelTotals.columns[aggr.colId];
-            groupTotals[aggr.colId] = this.applyAggrFunc(aggr.funcId, columnTotals, levelTotals);
-        }
-        if (this.aggrSettings.hasRecordCount()) {
-            groupTotals[this.aggrSettings.COUNT_FIELD_NAME] = levelTotals.count;
-        }
-        this.aggrContainer.updateAggregateData(levelIndex, groupKey, groupTotals);
-        this.resetLevelTotals(levelTotals);
-    };
-    DataTableAggregatesCalculator.prototype.applyAggrFunc = function (funcId, columnTotals, levelTotals) {
-        switch (funcId) {
-            case "SUM":
-                return columnTotals.sum;
-            case "AVG":
-                return columnTotals.sum / levelTotals.count;
-            case "COUNT":
-            case "CNTDST":
-                return levelTotals.count;
-            case "MIN":
-                return columnTotals.min;
-            case "MAX":
-                return columnTotals.max;
-        }
-    };
-    /** Updates the totals by values in the current DataRow
-     * and according to the specified aggregate
-    */
-    DataTableAggregatesCalculator.prototype.updateLevelTotals = function (levelIndex, row) {
-        var levelTotals = this.levelsTotals[levelIndex];
-        levelTotals.count += 1;
-        for (var _i = 0, _a = this.aggregates; _i < _a.length; _i++) {
-            var aggr = _a[_i];
-            var value = row.getValue(aggr.colId);
-            var columnTotals = levelTotals.columns[aggr.colId];
-            columnTotals.sum += value;
-            if (value < columnTotals.min) {
-                columnTotals.min = value;
-            }
-            if (value > columnTotals.max) {
-                columnTotals.max = value;
-            }
-        }
-    };
-    DataTableAggregatesCalculator.prototype.needRecalculation = function () {
-        return true;
-    };
-    DataTableAggregatesCalculator.prototype.reset = function () {
-    };
-    return DataTableAggregatesCalculator;
-}());
-export { DataTableAggregatesCalculator };
+import { EqAggregatesContainer } from '@easyquery/core';
+var DataTableAggregatesCalculator = /** @class */ (function () {
+    function DataTableAggregatesCalculator(context) {
+        this.context = context;
+        //stores current totals by level (group) number
+        this.levelsTotals = [];
+        this.prevRow = null;
+        this.aggrContainer = new EqAggregatesContainer(context);
+    }
+    DataTableAggregatesCalculator.prototype.getAggrContainer = function () {
+        return this.aggrContainer;
+    };
+    DataTableAggregatesCalculator.prototype.initObjects = function () {
+        var _this = this;
+        this.aggrSettings = this.context.getQuery().getAggregationSettings();
+        this.groups = this.aggrSettings.getGroups();
+        this.aggregates = this.aggrSettings.getAggregates();
+        this.aggrColIds = this.aggrSettings.getAggregates().map(function (a) { return a.colId; });
+        this.aggrCols = this.context.resultTable.columns.getItems()
+            .filter(function (col) { return _this.aggrColIds.indexOf(col.id) >= 0; });
+        this.levelsTotals = [];
+        this.prevRow = null;
+    };
+    DataTableAggregatesCalculator.prototype.createColumnAggregatesObject = function () {
+        return {
+            sum: 0,
+            min: Number.MAX_VALUE,
+            max: Number.MIN_VALUE
+        };
+    };
+    DataTableAggregatesCalculator.prototype.calculate = function (options) {
+        this.initObjects();
+        this.aggrContainer.clear();
+        options = options || {};
+        options.maxLevel = options.maxLevel >= 0
+            ? options.maxLevel : 0;
+        var levelNumber = this.groups.length + 1; //number of groups plus grand totals
+        for (var levelIndex = 0; levelIndex < levelNumber; levelIndex++) {
+            var levelTotals = { count: 0, columns: {} };
+            this.resetLevelTotals(levelTotals);
+            this.levelsTotals.push(levelTotals);
+        }
+        var allRows = this.context.resultTable.getCachedRows();
+        if (allRows.length > 0) {
+            for (var _i = 0, allRows_1 = allRows; _i < allRows_1.length; _i++) {
+                var row = allRows_1[_i];
+                this.processDataRow(row);
+            }
+            //flusing the totals for all group levels
+            for (var levelIndex = 1; levelIndex < levelNumber; levelIndex++) {
+                this.flushLevelTotals(levelIndex);
+            }
+            //flusing the grand totals (if they are turned on)
+            if (this.aggrSettings.hasGrandTotals()) {
+                this.flushLevelTotals(0);
+            }
+        }
+        return Promise.resolve();
+    };
+    DataTableAggregatesCalculator.prototype.resetLevelTotals = function (rowTotals) {
+        for (var _i = 0, _a = this.aggrCols; _i < _a.length; _i++) {
+            var aggrCol = _a[_i];
+            rowTotals.columns[aggrCol.id] = this.createColumnAggregatesObject();
+        }
+        rowTotals.count = 0;
+    };
+    DataTableAggregatesCalculator.prototype.processDataRow = function (row) {
+        var levelIndexChanged = this.checkLevelChange(row);
+        if (levelIndexChanged >= 0) {
+            for (var levelIndex_1 = levelIndexChanged; levelIndex_1 < this.levelsTotals.length; levelIndex_1++) {
+                this.flushLevelTotals(levelIndex_1);
+            }
+        }
+        if (this.aggrSettings.hasGrandTotals()) {
+            this.updateLevelTotals(0, row);
+        }
+        var levelIndex = 1;
+        for (var _i = 0, _a = this.groups; _i < _a.length; _i++) {
+            var group = _a[_i];
+            this.updateLevelTotals(levelIndex, row);
+            levelIndex++;
+        }
+        this.prevRow = row;
+    };
+    /** Checks if the values in group columns were changed
+        and return the level number they were */
+    DataTableAggregatesCalculator.prototype.checkLevelChange = function (row) {
+        if (this.prevRow == null)
+            return -1;
+        for (var groupIndex = 0; groupIndex < this.groups.length; groupIndex++) {
+            var group = this.groups[groupIndex];
+            for (var _i = 0, _a = group.columns; _i < _a.length; _i++) {
+                var colId = _a[_i];
+                var value = row.getValue(colId);
+                var prevValue = this.prevRow.getValue(colId);
+                if (!this.aggrSettings.compareValues(prevValue, value)) {
+                    return groupIndex + 1;
+                }
+            }
+        }
+        return -1;
+    };
+    /** Saves the current values in levelData for the specified level to AggregateContainer
+        and then reset the data row for that level
+    */
+    DataTableAggregatesCalculator.prototype.flushLevelTotals = function (levelIndex) {
+        var levelTotals = this.levelsTotals[levelIndex];
+        var group = levelIndex > 0 ? this.groups[levelIndex - 1] : null;
+        var groupKey = this.aggrSettings.buildGroupKey(group, this.prevRow);
+        var groupTotals = {};
+        for (var _i = 0, _a = this.aggregates; _i < _a.length; _i++) {
+            var aggr = _a[_i];
+            var columnTotals = levelTotals.columns[aggr.colId];
+            groupTotals[aggr.colId] = this.applyAggrFunc(aggr.funcId, columnTotals, levelTotals);
+        }
+        if (this.aggrSettings.hasRecordCount()) {
+            groupTotals[this.aggrSettings.COUNT_FIELD_NAME] = levelTotals.count;
+        }
+        this.aggrContainer.updateAggregateData(levelIndex, groupKey, groupTotals);
+        this.resetLevelTotals(levelTotals);
+    };
+    DataTableAggregatesCalculator.prototype.applyAggrFunc = function (funcId, columnTotals, levelTotals) {
+        switch (funcId) {
+            case "SUM":
+                return columnTotals.sum;
+            case "AVG":
+                return columnTotals.sum / levelTotals.count;
+            case "COUNT":
+            case "CNTDST":
+                return levelTotals.count;
+            case "MIN":
+                return columnTotals.min;
+            case "MAX":
+                return columnTotals.max;
+        }
+    };
+    /** Updates the totals by values in the current DataRow
+     * and according to the specified aggregate
+    */
+    DataTableAggregatesCalculator.prototype.updateLevelTotals = function (levelIndex, row) {
+        var levelTotals = this.levelsTotals[levelIndex];
+        levelTotals.count += 1;
+        for (var _i = 0, _a = this.aggregates; _i < _a.length; _i++) {
+            var aggr = _a[_i];
+            var value = row.getValue(aggr.colId);
+            var columnTotals = levelTotals.columns[aggr.colId];
+            columnTotals.sum += value;
+            if (value < columnTotals.min) {
+                columnTotals.min = value;
+            }
+            if (value > columnTotals.max) {
+                columnTotals.max = value;
+            }
+        }
+    };
+    DataTableAggregatesCalculator.prototype.needRecalculation = function () {
+        return true;
+    };
+    DataTableAggregatesCalculator.prototype.reset = function () {
+    };
+    return DataTableAggregatesCalculator;
+}());
+export { DataTableAggregatesCalculator };
 //# sourceMappingURL=data_table_aggr_calculator.js.map

package/dist/lib/data/eqs_aggr_calculator.d.ts

@@ -1,14 +1,14 @@
-import { AggregatesCalculator, AggregatesContainer, AggrCalculationOptions } from '@easydata/core';
-import { EqContext } from '@easyquery/core';
-export declare class EqServerAggregatesCalculator implements AggregatesCalculator {
-    protected context: EqContext;
-    constructor(context: EqContext);
-    private aggrContainer;
-    getAggrContainer(): AggregatesContainer;
-    calculate(options?: AggrCalculationOptions): Promise<void>;
-    private processLevel;
-    private buildLevelData;
-    private _needRecalculation;
-    needRecalculation(): boolean;
-    reset(): void;
-}
+import { AggregatesCalculator, AggregatesContainer, AggrCalculationOptions } from '@easydata/core';
+import { EqContext } from '@easyquery/core';
+export declare class EqServerAggregatesCalculator implements AggregatesCalculator {
+    protected context: EqContext;
+    constructor(context: EqContext);
+    private aggrContainer;
+    getAggrContainer(): AggregatesContainer;
+    calculate(options?: AggrCalculationOptions): Promise<void>;
+    private processLevel;
+    private buildLevelData;
+    private _needRecalculation;
+    needRecalculation(): boolean;
+    reset(): void;
+}