@resolveio/server-lib 9.0.34 → 9.0.36

package/methods/report-builder.js

@@ -1,66 +1,124 @@
-import SimpleSchema from 'simpl-schema';
-import { PaginationOptionsSchema } from '../models/pagination.model';
-import { ResolveIOServer } from '../index';
-import { getReportLookupSchemas, buildTree, mongoCommand } from '../util/schema-report-builder';
-export function loadReportBuilderMethods(methodManager) {
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadReportBuilderMethods = void 0;
+var simpl_schema_1 = require("simpl-schema");
+var pagination_model_1 = require("../models/pagination.model");
+var index_1 = require("../index");
+var schema_report_builder_1 = require("../util/schema-report-builder");
+function loadReportBuilderMethods(methodManager) {
     methodManager.methods({
         reportBuilderBuildTree: {
             skipQueue: true,
-            check: new SimpleSchema({
+            check: new simpl_schema_1.default({
                 collection_root: {
                     type: String
                 }
             }),
             function: function (collection_root) {
-                return new Promise(async (resolve, reject) => {
-                    let lookupSchemaData = getReportLookupSchemas(collection_root).sort((a, b) => a.collection_name.localeCompare(b.collection_name));
-                    let lookupSchemaTree = lookupSchemaData.filter(a => a.is_root === true)[0].tree;
-                    let treeItems = buildTree(collection_root, lookupSchemaTree);
-                    Object.keys(lookupSchemaTree).filter(a => a.endsWith('(Lookup)')).forEach(lookup => {
-                        let fieldPath = lookup.split('.');
-                        let field = null;
-                        fieldPath.forEach(path => {
-                            if (!field) {
-                                field = treeItems.filter(a => a.fieldName === path)[0];
-                            }
-                            else {
-                                field = field.children.filter(a => a.fieldName === path)[0];
-                            }
+                var _this = this;
+                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var lookupSchemaData, lookupSchemaTree, treeItems;
+                    return __generator(this, function (_a) {
+                        lookupSchemaData = schema_report_builder_1.getReportLookupSchemas(collection_root).sort(function (a, b) { return a.collection_name.localeCompare(b.collection_name); });
+                        lookupSchemaTree = lookupSchemaData.filter(function (a) { return a.is_root === true; })[0].tree;
+                        treeItems = schema_report_builder_1.buildTree(collection_root, lookupSchemaTree);
+                        Object.keys(lookupSchemaTree).filter(function (a) { return a.endsWith('(Lookup)'); }).forEach(function (lookup) {
+                            var fieldPath = lookup.split('.');
+                            var field = null;
+                            fieldPath.forEach(function (path) {
+                                if (!field) {
+                                    field = treeItems.filter(function (a) { return a.fieldName === path; })[0];
+                                }
+                                else {
+                                    field = field.children.filter(function (a) { return a.fieldName === path; })[0];
+                                }
+                            });
+                            field.children = schema_report_builder_1.buildTree(lookupSchemaTree[lookup].lookup_collection, lookupSchemaData.filter(function (a) { return a.collection_name === lookupSchemaTree[lookup].lookup_collection; })[0].tree, field);
                         });
-                        field.children = buildTree(lookupSchemaTree[lookup].lookup_collection, lookupSchemaData.filter(a => a.collection_name === lookupSchemaTree[lookup].lookup_collection)[0].tree, field);
+                        // console.log('----------- Tree Items -----------', treeItems);
+                        resolve({ isLeaf: false, children: treeItems });
+                        return [2 /*return*/];
                     });
-                    // console.log('----------- Tree Items -----------', treeItems);
-                    resolve({ isLeaf: false, children: treeItems });
-                });
+                }); });
             }
         },
         reportBuilderGetDistinctValue: {
             skipQueue: true,
-            check: new SimpleSchema({
+            check: new simpl_schema_1.default({
                 treeLeaf: {
                     type: Object,
                     blackbox: true
                 }
             }),
             function: function (treeLeaf) {
-                return new Promise(async (resolve, reject) => {
-                    if (treeLeaf.fieldType === 'String') {
-                        if (treeLeaf.fieldPath.includes('(Lookup)')) {
-                            resolve(await mongoCommand('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/^.+\(.+\) \(Lookup\)\.\$\./g, '').replace(/\.\$/g, '')));
-                        }
-                        else {
-                            resolve(await mongoCommand('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/\.\$/g, '')));
+                var _this = this;
+                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var _a, _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                if (!(treeLeaf.fieldType === 'String')) return [3 /*break*/, 5];
+                                if (!treeLeaf.fieldPath.includes('(Lookup)')) return [3 /*break*/, 2];
+                                _a = resolve;
+                                return [4 /*yield*/, schema_report_builder_1.mongoCommand('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/^.+\(.+\) \(Lookup\)\.\$\./g, '').replace(/\.\$/g, ''))];
+                            case 1:
+                                _a.apply(void 0, [_c.sent()]);
+                                return [3 /*break*/, 4];
+                            case 2:
+                                _b = resolve;
+                                return [4 /*yield*/, schema_report_builder_1.mongoCommand('distinct', treeLeaf.collection_name, treeLeaf.fieldPath.replace(/\.\$/g, ''))];
+                            case 3:
+                                _b.apply(void 0, [_c.sent()]);
+                                _c.label = 4;
+                            case 4: return [3 /*break*/, 6];
+                            case 5:
+                                resolve([]);
+                                _c.label = 6;
+                            case 6: return [2 /*return*/];
                         }
-                    }
-                    else {
-                        resolve([]);
-                    }
-                });
+                    });
+                }); });
             }
         },
         reportBuilderGetResults: {
             skipQueue: true,
-            check: new SimpleSchema({
+            check: new simpl_schema_1.default({
                 reportType: {
                     type: String
                 },
@@ -68,7 +126,7 @@ export function loadReportBuilderMethods(methodManager) {
                     type: String
                 },
                 options: {
-                    type: PaginationOptionsSchema
+                    type: pagination_model_1.PaginationOptionsSchema
                 },
                 filters: {
                     type: Array,
@@ -149,590 +207,624 @@ export function loadReportBuilderMethods(methodManager) {
                     optional: true
                 }
             }),
-            function: function (reportType, rootCollectionName, rootOptions, filters = [], filterArrays = [], filterArrayFields = [], selectedFields = [], customFields = [], groupsRow = [], fieldsTotal = [], fieldsLink = [], date_field = '', date_interval = '', displayType = '') {
-                return new Promise(async (resolve, reject) => {
-                    let modelCollection = ResolveIOServer.getMongoManager().collection(rootCollectionName);
-                    if (!modelCollection) {
-                        reject('Invalid collection');
-                    }
-                    else {
-                        // Query
-                        let query = [];
-                        // Non-Lookup Match Filters
-                        let initialQueryMatchCondition = {
-                            $and: []
-                        };
-                        // selectedFields.filter(a => a.collection_name === rootCollectionName).forEach(field => {
-                        // 	initialQueryMatchCondition['$and'].push({
-                        // 		$and: [
-                        // 			{[field.fieldPath.replace(/\.\$/g, '')]: {$exists: 1}},
-                        // 			// {[field.fieldPath.replace(/\.\$/g, '')]: {$ne: ''}},
-                        // 			{[field.fieldPath.replace(/\.\$/g, '')]: {$ne: null}},
-                        // 		]
-                        // 	});
-                        // });
-                        if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length) {
-                            filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).forEach(filter => {
-                                initialQueryMatchCondition['$and'].push(filter);
-                            });
-                        }
-                        // Add filter to query
-                        // if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length || selectedFields.filter(a => !a.fieldPath.includes('(Lookup')).length) {
-                        if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length) {
-                            query.push({
-                                $match: initialQueryMatchCondition
-                            });
-                        }
-                        // Add count
-                        query.push({ $addFields: { count: { $sum: 1 } } });
-                        let sizes = [];
-                        filterArrayFields.filter(a => a.fieldPath).forEach(filterField => {
-                            let fieldData = filterField.fieldPath.split('.$');
-                            let fieldPath = '';
-                            for (let i = 0; i < fieldData.length - 1; i++) {
-                                fieldPath += fieldData[i];
-                                if (fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup)')) {
-                                    if (!query.some(a => a.$lookup && a.$lookup.as === filterField.lookup_as.replace(/\.\$/g, ''))) {
-                                        query.push({ $lookup: {
-                                                from: filterField.lookup_collection,
-                                                localField: filterField.lookup_local_key,
-                                                foreignField: filterField.lookup_foreign_key,
-                                                as: filterField.lookup_as.replace(/\.\$/g, '')
-                                            } });
-                                        sizes.push(filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
-                                        query.push({ $addFields: { ['size_' + filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_')]: { $size: { $ifNull: ['$' + filterField.lookup_as.replace(/\.\$/g, '').replace(/\./g, '_'), []] } } } });
-                                        query.push({ '$unwind': { path: '$' + filterField.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
-                                    }
+            function: function (reportType, rootCollectionName, rootOptions, filters, filterArrays, filterArrayFields, selectedFields, customFields, groupsRow, fieldsTotal, fieldsLink, date_field, date_interval, displayType) {
+                var _this = this;
+                if (filters === void 0) { filters = []; }
+                if (filterArrays === void 0) { filterArrays = []; }
+                if (filterArrayFields === void 0) { filterArrayFields = []; }
+                if (selectedFields === void 0) { selectedFields = []; }
+                if (customFields === void 0) { customFields = []; }
+                if (groupsRow === void 0) { groupsRow = []; }
+                if (fieldsTotal === void 0) { fieldsTotal = []; }
+                if (fieldsLink === void 0) { fieldsLink = []; }
+                if (date_field === void 0) { date_field = ''; }
+                if (date_interval === void 0) { date_interval = ''; }
+                if (displayType === void 0) { displayType = ''; }
+                return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+                    var modelCollection, query_1, initialQueryMatchCondition_1, sizes_1, divFields_1, queryMatchConditionLookup_1, queryGroup_1, queryProjection_1, _loop_1, i, res_1, err_1, tmpTotals_1, tmpRes;
+                    var _this = this;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                modelCollection = index_1.ResolveIOServer.getMongoManager().collection(rootCollectionName);
+                                if (!!modelCollection) return [3 /*break*/, 1];
+                                reject('Invalid collection');
+                                return [3 /*break*/, 6];
+                            case 1:
+                                query_1 = [];
+                                initialQueryMatchCondition_1 = {
+                                    $and: []
+                                };
+                                // selectedFields.filter(a => a.collection_name === rootCollectionName).forEach(field => {
+                                // 	initialQueryMatchCondition['$and'].push({
+                                // 		$and: [
+                                // 			{[field.fieldPath.replace(/\.\$/g, '')]: {$exists: 1}},
+                                // 			// {[field.fieldPath.replace(/\.\$/g, '')]: {$ne: ''}},
+                                // 			{[field.fieldPath.replace(/\.\$/g, '')]: {$ne: null}},
+                                // 		]
+                                // 	});
+                                // });
+                                if (filters.filter(function (a) { return (!a['$or'] && !Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && !a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).length) {
+                                    filters.filter(function (a) { return (!a['$or'] && !Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && !a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).forEach(function (filter) {
+                                        initialQueryMatchCondition_1['$and'].push(filter);
+                                    });
                                 }
-                                else {
-                                    if (!query.some(a => a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')))) {
-                                        sizes.push(fieldPath.replace(/\./g, '_'));
-                                        query.push({ $addFields: { ['size_' + fieldPath.replace(/\./g, '_')]: { $size: { $ifNull: ['$' + fieldPath, []] } } } });
-                                        query.push({ '$unwind': { path: '$' + fieldPath, preserveNullAndEmptyArrays: true } });
-                                    }
+                                // Add filter to query
+                                // if (filters.filter(a => (!a['$or'] && !Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && !a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length || selectedFields.filter(a => !a.fieldPath.includes('(Lookup')).length) {
+                                if (filters.filter(function (a) { return (!a['$or'] && !Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && !a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).length) {
+                                    query_1.push({
+                                        $match: initialQueryMatchCondition_1
+                                    });
                                 }
-                            }
-                        });
-                        // Groups - Lookups / Sizes / Unwinds
-                        groupsRow.forEach(row => {
-                            if (row.field.includes('$')) {
-                                let fieldData = row.field.split('.$');
-                                let fieldPath = '';
-                                for (let i = 0; i < fieldData.length - 1; i++) {
-                                    fieldPath += fieldData[i];
-                                    if (fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup)')) {
-                                        if (!query.some(a => a.$lookup && a.$lookup.as === row.treeItem.lookup_as.replace(/\.\$/g, ''))) {
-                                            query.push({ $lookup: {
-                                                    from: row.treeItem.lookup_collection,
-                                                    localField: row.treeItem.lookup_local_key,
-                                                    foreignField: row.treeItem.lookup_foreign_key,
-                                                    as: row.treeItem.lookup_as.replace(/\.\$/g, '')
-                                                } });
-                                            sizes.push(row.treeItem.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
-                                            query.push({ $addFields: { ['size_' + row.treeItem.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_')]: { $size: { $ifNull: ['$' + row.treeItem.lookup_as.replace(/\.\$/g, '').replace(/\./g, '_'), []] } } } });
-                                            query.push({ '$unwind': { path: '$' + row.treeItem.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
+                                // Add count
+                                query_1.push({ $addFields: { count: { $sum: 1 } } });
+                                sizes_1 = [];
+                                filterArrayFields.filter(function (a) { return a.fieldPath; }).forEach(function (filterField) {
+                                    var _a, _b;
+                                    var fieldData = filterField.fieldPath.split('.$');
+                                    var fieldPath = '';
+                                    for (var i = 0; i < fieldData.length - 1; i++) {
+                                        fieldPath += fieldData[i];
+                                        if (fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup)')) {
+                                            if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === filterField.lookup_as.replace(/\.\$/g, ''); })) {
+                                                query_1.push({ $lookup: {
+                                                        from: filterField.lookup_collection,
+                                                        localField: filterField.lookup_local_key,
+                                                        foreignField: filterField.lookup_foreign_key,
+                                                        as: filterField.lookup_as.replace(/\.\$/g, '')
+                                                    } });
+                                                sizes_1.push(filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
+                                                query_1.push({ $addFields: (_a = {}, _a['size_' + filterField.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_')] = { $size: { $ifNull: ['$' + filterField.lookup_as.replace(/\.\$/g, '').replace(/\./g, '_'), []] } }, _a) });
+                                                query_1.push({ '$unwind': { path: '$' + filterField.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
+                                            }
                                         }
-                                    }
-                                    else {
-                                        if (!query.some(a => a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')))) {
-                                            sizes.push(fieldPath.replace(/\./g, '_'));
-                                            query.push({ $addFields: { ['size_' + fieldPath.replace(/\./g, '_')]: { $size: { $ifNull: ['$' + fieldPath, []] } } } });
-                                            query.push({ '$unwind': { path: '$' + fieldPath, preserveNullAndEmptyArrays: true } });
+                                        else {
+                                            if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')); })) {
+                                                sizes_1.push(fieldPath.replace(/\./g, '_'));
+                                                query_1.push({ $addFields: (_b = {}, _b['size_' + fieldPath.replace(/\./g, '_')] = { $size: { $ifNull: ['$' + fieldPath, []] } }, _b) });
+                                                query_1.push({ '$unwind': { path: '$' + fieldPath, preserveNullAndEmptyArrays: true } });
+                                            }
                                         }
                                     }
-                                }
-                            }
-                        });
-                        // Selected Fields - Lookups / Sizes / Unwinds
-                        selectedFields.forEach(field => {
-                            if (field.fieldPath.includes('$')) {
-                                let fieldData = field.fieldPath.split('.$');
-                                let fieldPath = '';
-                                for (let i = 0; i < fieldData.length - 1; i++) {
-                                    fieldPath += fieldData[i];
-                                    if (fieldPath.split('.$')[fieldPath.split('.$').length - 1].includes('(Lookup)')) {
-                                        if (!query.some(a => a.$lookup && a.$lookup.as === field.lookup_as.replace(/\.\$/g, ''))) {
-                                            query.push({ $lookup: {
-                                                    from: field.lookup_collection,
-                                                    localField: field.lookup_local_key,
-                                                    foreignField: field.lookup_foreign_key,
-                                                    as: field.lookup_as.replace(/\.\$/g, '')
-                                                } });
-                                            sizes.push(field.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
-                                            query.push({ $addFields: { ['size_' + field.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_')]: { $size: { $ifNull: ['$' + field.lookup_as.replace(/\.\$/g, '').replace(/\./g, '_'), []] } } } });
-                                            query.push({ '$unwind': { path: '$' + field.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
+                                });
+                                // Groups - Lookups / Sizes / Unwinds
+                                groupsRow.forEach(function (row) {
+                                    var _a, _b;
+                                    if (row.field.includes('$')) {
+                                        var fieldData = row.field.split('.$');
+                                        var fieldPath_1 = '';
+                                        for (var i = 0; i < fieldData.length - 1; i++) {
+                                            fieldPath_1 += fieldData[i];
+                                            if (fieldPath_1.split('.$')[fieldPath_1.split('.$').length - 1].includes('(Lookup)')) {
+                                                if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === row.treeItem.lookup_as.replace(/\.\$/g, ''); })) {
+                                                    query_1.push({ $lookup: {
+                                                            from: row.treeItem.lookup_collection,
+                                                            localField: row.treeItem.lookup_local_key,
+                                                            foreignField: row.treeItem.lookup_foreign_key,
+                                                            as: row.treeItem.lookup_as.replace(/\.\$/g, '')
+                                                        } });
+                                                    sizes_1.push(row.treeItem.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
+                                                    query_1.push({ $addFields: (_a = {}, _a['size_' + row.treeItem.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_')] = { $size: { $ifNull: ['$' + row.treeItem.lookup_as.replace(/\.\$/g, '').replace(/\./g, '_'), []] } }, _a) });
+                                                    query_1.push({ '$unwind': { path: '$' + row.treeItem.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
+                                                }
+                                            }
+                                            else {
+                                                if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath_1.replace(/\./g, '_')); })) {
+                                                    sizes_1.push(fieldPath_1.replace(/\./g, '_'));
+                                                    query_1.push({ $addFields: (_b = {}, _b['size_' + fieldPath_1.replace(/\./g, '_')] = { $size: { $ifNull: ['$' + fieldPath_1, []] } }, _b) });
+                                                    query_1.push({ '$unwind': { path: '$' + fieldPath_1, preserveNullAndEmptyArrays: true } });
+                                                }
+                                            }
                                         }
-                                        else {
-                                            if (!fieldData[i].includes('(Lookup)')) {
-                                                if (!query.some(a => a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')))) {
-                                                    sizes.push(fieldPath.replace(/\./g, '_'));
-                                                    query.push({ $addFields: { ['size_' + fieldPath.replace(/\./g, '_')]: { $size: { $ifNull: ['$' + fieldPath, []] } } } });
-                                                    query.push({ '$unwind': { path: '$' + fieldPath, preserveNullAndEmptyArrays: true } });
+                                    }
+                                });
+                                // Selected Fields - Lookups / Sizes / Unwinds
+                                selectedFields.forEach(function (field) {
+                                    var _a, _b, _c;
+                                    if (field.fieldPath.includes('$')) {
+                                        var fieldData = field.fieldPath.split('.$');
+                                        var fieldPath_2 = '';
+                                        for (var i = 0; i < fieldData.length - 1; i++) {
+                                            fieldPath_2 += fieldData[i];
+                                            if (fieldPath_2.split('.$')[fieldPath_2.split('.$').length - 1].includes('(Lookup)')) {
+                                                if (!query_1.some(function (a) { return a.$lookup && a.$lookup.as === field.lookup_as.replace(/\.\$/g, ''); })) {
+                                                    query_1.push({ $lookup: {
+                                                            from: field.lookup_collection,
+                                                            localField: field.lookup_local_key,
+                                                            foreignField: field.lookup_foreign_key,
+                                                            as: field.lookup_as.replace(/\.\$/g, '')
+                                                        } });
+                                                    sizes_1.push(field.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_'));
+                                                    query_1.push({ $addFields: (_a = {}, _a['size_' + field.lookup_as.replace(/\.\$\./g, '_').replace(/\./g, '_')] = { $size: { $ifNull: ['$' + field.lookup_as.replace(/\.\$/g, '').replace(/\./g, '_'), []] } }, _a) });
+                                                    query_1.push({ '$unwind': { path: '$' + field.lookup_as.replace(/\.\$/g, ''), preserveNullAndEmptyArrays: true } });
+                                                }
+                                                else {
+                                                    if (!fieldData[i].includes('(Lookup)')) {
+                                                        if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath_2.replace(/\./g, '_')); })) {
+                                                            sizes_1.push(fieldPath_2.replace(/\./g, '_'));
+                                                            query_1.push({ $addFields: (_b = {}, _b['size_' + fieldPath_2.replace(/\./g, '_')] = { $size: { $ifNull: ['$' + fieldPath_2, []] } }, _b) });
+                                                            query_1.push({ '$unwind': { path: '$' + fieldPath_2, preserveNullAndEmptyArrays: true } });
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            else {
+                                                if (!query_1.some(function (a) { return a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath_2.replace(/\./g, '_')); })) {
+                                                    sizes_1.push(fieldPath_2.replace(/\./g, '_'));
+                                                    query_1.push({ $addFields: (_c = {}, _c['size_' + fieldPath_2.replace(/\./g, '_')] = { $size: { $ifNull: ['$' + fieldPath_2, []] } }, _c) });
+                                                }
+                                                if (field.leafValueType !== 'Count' && !query_1.some(function (a) { return a.$unwind && a.$unwind.path === '$' + fieldPath_2; })) {
+                                                    query_1.push({ '$unwind': { path: '$' + fieldPath_2, preserveNullAndEmptyArrays: true } });
                                                 }
                                             }
                                         }
                                     }
-                                    else {
-                                        if (!query.some(a => a.$addFields && Object.keys(a.$addFields).includes('size_' + fieldPath.replace(/\./g, '_')))) {
-                                            sizes.push(fieldPath.replace(/\./g, '_'));
-                                            query.push({ $addFields: { ['size_' + fieldPath.replace(/\./g, '_')]: { $size: { $ifNull: ['$' + fieldPath, []] } } } });
+                                });
+                                divFields_1 = { $addFields: {} };
+                                fieldsTotal.filter(function (a) { return a.type === 'sum'; }).forEach(function (total) {
+                                    selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                        var multFields = [];
+                                        if (!field.fieldPath.includes('.$')) {
+                                            sizes_1.forEach(function (size) {
+                                                multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                            });
+                                        }
+                                        else {
+                                            sizes_1.filter(function (a) { return !field.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !filterArrayFields.filter(function (a) { return a.fieldPath; }).some(function (b) { return b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !fieldsLink.some(function (b) { return b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }); }).forEach(function (size) {
+                                                multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                            });
                                         }
-                                        if (field.leafValueType !== 'Count' && !query.some(a => a.$unwind && a.$unwind.path === '$' + fieldPath)) {
-                                            query.push({ '$unwind': { path: '$' + fieldPath, preserveNullAndEmptyArrays: true } });
+                                        if (multFields.length) {
+                                            if (field.leafValueType === 'Count') {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = {
+                                                    $divide: ['$count', { $multiply: multFields }]
+                                                };
+                                            }
+                                            else {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = {
+                                                    $divide: ['$' + field.fieldPath.replace(/\.\$/g, ''), { $multiply: multFields }]
+                                                };
+                                            }
+                                        }
+                                        else {
+                                            if (field.leafValueType === 'Count') {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = '$count';
+                                            }
+                                            else {
+                                                divFields_1.$addFields[total.id + '_' + field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
+                                            }
                                         }
-                                    }
-                                }
-                            }
-                        });
-                        // Divide all number fields by sizes
-                        let divFields = { $addFields: {} };
-                        fieldsTotal.filter(a => a.type === 'sum').forEach(total => {
-                            selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-                                let multFields = [];
-                                if (!field.fieldPath.includes('.$')) {
-                                    sizes.forEach(size => {
-                                        multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
                                     });
-                                }
-                                else {
-                                    sizes.filter(a => !field.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !filterArrayFields.filter(a => a.fieldPath).some(b => b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !fieldsLink.some(b => b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a))).forEach(size => {
+                                });
+                                selectedFields.filter(function (a) { return a.fieldType === 'Number' && a.leafValueType === 'Sum'; }).forEach(function (field) {
+                                    var multFields = [];
+                                    sizes_1.filter(function (a) { return !field.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(function (b) { return b.field.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !filterArrayFields.filter(function (a) { return a.fieldPath; }).some(function (b) { return b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !fieldsLink.some(function (b) { return b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }); }).forEach(function (size) {
                                         multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
                                     });
-                                }
-                                if (multFields.length) {
-                                    if (field.leafValueType === 'Count') {
-                                        divFields.$addFields[total.id + '_' + field.id] = {
-                                            $divide: ['$count', { $multiply: multFields }]
-                                        };
-                                    }
-                                    else {
-                                        divFields.$addFields[total.id + '_' + field.id] = {
+                                    if (multFields.length) {
+                                        divFields_1.$addFields[field.fieldPath.replace(/\.\$/g, '')] = {
                                             $divide: ['$' + field.fieldPath.replace(/\.\$/g, ''), { $multiply: multFields }]
                                         };
                                     }
-                                }
-                                else {
-                                    if (field.leafValueType === 'Count') {
-                                        divFields.$addFields[total.id + '_' + field.id] = '$count';
+                                });
+                                selectedFields.filter(function (a) { return a.leafValueType === 'Count'; }).forEach(function (field) {
+                                    var multFields = [];
+                                    sizes_1.filter(function (a) { return !field.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(function (b) { return b.field.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !filterArrayFields.filter(function (a) { return a.fieldPath; }).some(function (b) { return b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }) && !fieldsLink.some(function (b) { return b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a); }); }).forEach(function (size) {
+                                        multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
+                                    });
+                                    if (multFields.length) {
+                                        divFields_1.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = {
+                                            $divide: ['$count', { $multiply: multFields }]
+                                        };
                                     }
                                     else {
-                                        divFields.$addFields[total.id + '_' + field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
+                                        if (reportType !== 'Dated' && sizes_1.filter(function (a) { return field.fieldPath.replace(/\.\$\./g, '_').includes(a); }).length) {
+                                            sizes_1.filter(function (a) { return field.fieldPath.replace(/\.\$\./g, '_').includes(a); }).forEach(function (size) {
+                                                divFields_1.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = '$size_' + size;
+                                            });
+                                        }
+                                        else {
+                                            divFields_1.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = '$count';
+                                        }
                                     }
+                                });
+                                fieldsTotal.filter(function (a) { return a.type === 'avg'; }).forEach(function (total) {
+                                    selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                        divFields_1.$addFields[total.id + '_' + field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
+                                    });
+                                });
+                                if (Object.keys(divFields_1.$addFields).length > 0) {
+                                    query_1.push(divFields_1);
                                 }
-                            });
-                        });
-                        selectedFields.filter(a => a.fieldType === 'Number' && a.leafValueType === 'Sum').forEach(field => {
-                            let multFields = [];
-                            sizes.filter(a => !field.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(b => b.field.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !filterArrayFields.filter(a => a.fieldPath).some(b => b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !fieldsLink.some(b => b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a))).forEach(size => {
-                                multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
-                            });
-                            if (multFields.length) {
-                                divFields.$addFields[field.fieldPath.replace(/\.\$/g, '')] = {
-                                    $divide: ['$' + field.fieldPath.replace(/\.\$/g, ''), { $multiply: multFields }]
-                                };
-                            }
-                        });
-                        selectedFields.filter(a => a.leafValueType === 'Count').forEach(field => {
-                            let multFields = [];
-                            sizes.filter(a => !field.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) && !groupsRow.some(b => b.field.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !filterArrayFields.filter(a => a.fieldPath).some(b => b.fieldPath.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a)) && !fieldsLink.some(b => b.field_first.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a) || b.field_second.replace(/\.\$\./g, '_').replace(/\./g, '_').includes(a))).forEach(size => {
-                                multFields.push({ $cond: { if: { $gt: ['$size_' + size, 0] }, then: '$size_' + size, else: 1 } });
-                            });
-                            if (multFields.length) {
-                                divFields.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = {
-                                    $divide: ['$count', { $multiply: multFields }]
+                                fieldsLink.filter(function (a) { return a.field_first && a.field_second; }).forEach(function (link) {
+                                    var _a, _b;
+                                    query_1.push({ $addFields: (_a = {}, _a[link.id] = { $cmp: ['$' + link.field_first.replace(/\.\$/g, ''), '$' + link.field_second.replace(/\.\$/g, '')] }, _a) });
+                                    query_1.push({ $match: (_b = {}, _b[link.id] = 0, _b) });
+                                });
+                                customFields.forEach(function (cust) {
+                                    cust.operations.filter(function (a) { return a.operation && !a.fields.some(function (b) { return (b.field === null || b.field === '') && b.value === null; }); }).forEach(function (operation, opIndex) {
+                                        var _a, _b;
+                                        var custFieldGroup = {};
+                                        if (operation.operation === 'divide') {
+                                            var condCheck_1 = [];
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    condCheck_1.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), 0] });
+                                                    condCheck_1.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), null] });
+                                                }
+                                                else {
+                                                    condCheck_1.push({ $eq: [field.value, 0] });
+                                                    condCheck_1.push({ $eq: [field.value, null] });
+                                                }
+                                            });
+                                            if (opIndex > 0) {
+                                                condCheck_1.push({ $eq: ['$' + cust.selFieldId, 0] });
+                                                condCheck_1.push({ $eq: ['$' + cust.selFieldId, null] });
+                                            }
+                                            var tmpOperationFields_1 = [];
+                                            if (opIndex > 0) {
+                                                tmpOperationFields_1.push('$' + cust.selFieldId);
+                                            }
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    tmpOperationFields_1.push('$' + field.field.replace(/\.\$/g, ''));
+                                                }
+                                                else {
+                                                    tmpOperationFields_1.push(field.value);
+                                                }
+                                            });
+                                            custFieldGroup[cust.selFieldId] = {
+                                                $cond: { if: { $or: condCheck_1 }, then: 0, else: (_a = {}, _a['$' + operation.operation] = tmpOperationFields_1, _a) }
+                                            };
+                                        }
+                                        else {
+                                            custFieldGroup[cust.selFieldId] = (_b = {},
+                                                _b['$' + operation.operation] = [],
+                                                _b);
+                                            if (opIndex > 0) {
+                                                custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $eq: ['$' + cust.selFieldId, null] }, then: 0, else: '$' + cust.selFieldId } });
+                                            }
+                                            var condOr_1 = [];
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    condOr_1.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), null] });
+                                                }
+                                                else {
+                                                    condOr_1.push({ $eq: [field.value, null] });
+                                                }
+                                            });
+                                            operation.fields.filter(function (a) { return a.field || a.value !== null; }).forEach(function (field) {
+                                                if (field.field) {
+                                                    custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $or: condOr_1 }, then: 0, else: '$' + field.field.replace(/\.\$/g, '') } });
+                                                }
+                                                else {
+                                                    custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $or: condOr_1 }, then: 0, else: field.value } });
+                                                }
+                                            });
+                                        }
+                                        query_1.push({ $addFields: custFieldGroup });
+                                    });
+                                });
+                                fieldsTotal.forEach(function (total) {
+                                    customFields.forEach(function (field) {
+                                        var _a;
+                                        query_1.push({ $addFields: (_a = {}, _a[total.id + '_' + field.selFieldId] = '$' + field.selFieldId, _a) });
+                                    });
+                                });
+                                queryMatchConditionLookup_1 = {
+                                    $and: []
                                 };
-                            }
-                            else {
-                                if (reportType !== 'Dated' && sizes.filter(a => field.fieldPath.replace(/\.\$\./g, '_').includes(a)).length) {
-                                    sizes.filter(a => field.fieldPath.replace(/\.\$\./g, '_').includes(a)).forEach(size => {
-                                        divFields.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = '$size_' + size;
+                                if (filters.filter(function (a) { return (!a['$or'] && Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).length) {
+                                    filters.filter(function (a) { return (!a['$or'] && Object.keys(a).some(function (b) { return b.includes('(Lookup)'); })) || (a['$or'] && a['$or'].some(function (b) { return Object.keys(b).some(function (c) { return c.includes('(Lookup)'); }); })); }).forEach(function (filter) {
+                                        queryMatchConditionLookup_1['$and'].push(filter);
                                     });
                                 }
-                                else {
-                                    divFields.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = '$count';
+                                filterArrays.forEach(function (filter) {
+                                    queryMatchConditionLookup_1['$and'].push(filter);
+                                });
+                                if (queryMatchConditionLookup_1.$and.length) {
+                                    query_1.push({ $match: queryMatchConditionLookup_1 });
                                 }
-                            }
-                        });
-                        fieldsTotal.filter(a => a.type === 'avg').forEach(total => {
-                            selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-                                divFields.$addFields[total.id + '_' + field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
-                            });
-                        });
-                        if (Object.keys(divFields.$addFields).length > 0) {
-                            query.push(divFields);
-                        }
-                        fieldsLink.filter(a => a.field_first && a.field_second).forEach(link => {
-                            query.push({ $addFields: { [link.id]: { $cmp: ['$' + link.field_first.replace(/\.\$/g, ''), '$' + link.field_second.replace(/\.\$/g, '')] } } });
-                            query.push({ $match: { [link.id]: 0 } });
-                        });
-                        customFields.forEach(cust => {
-                            cust.operations.filter(a => a.operation && !a.fields.some(b => (b.field === null || b.field === '') && b.value === null)).forEach((operation, opIndex) => {
-                                let custFieldGroup = {};
-                                if (operation.operation === 'divide') {
-                                    let condCheck = [];
-                                    operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-                                        if (field.field) {
-                                            condCheck.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), 0] });
-                                            condCheck.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), null] });
+                                queryGroup_1 = {
+                                    _id: {}
+                                };
+                                if (groupsRow.length || !displayType || displayType === 'grouped') {
+                                    if (!groupsRow.length) {
+                                        queryGroup_1._id = '$_id';
+                                    }
+                                    groupsRow.forEach(function (row) {
+                                        queryGroup_1._id[row.id] = '$' + row.field.replace(/\.\$/g, '');
+                                        if (date_field && date_interval) {
+                                            if (date_interval === 'Daily') {
+                                                queryGroup_1._id['day'] = { '$dayOfMonth': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                                queryGroup_1._id['month'] = { '$month': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                            }
+                                            else if (date_interval === 'Weekly') {
+                                                queryGroup_1._id['week'] = { '$isoWeek': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                                queryGroup_1._id['year'] = { '$isoWeekYear': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                            }
+                                            else if (date_interval === 'Monthly') {
+                                                queryGroup_1._id['month'] = { '$month': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                            }
+                                            else if (date_interval === 'Quarterly') {
+                                                queryGroup_1._id['month'] = { '$month': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                                queryGroup_1._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                            }
+                                            else if (date_interval === 'Yearly') {
+                                                queryGroup_1._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': _this.serverConfig['TIMEZONE'] } };
+                                            }
+                                        }
+                                    });
+                                    selectedFields.forEach(function (field) {
+                                        if (field.leafValueType === 'Average') {
+                                            queryGroup_1[field.id] = { '$avg': '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Sum') {
+                                            queryGroup_1[field.id] = { '$sum': '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Count') {
+                                            if (reportType === 'Dated') {
+                                                queryGroup_1[field.id] = { '$sum': '$count_' + field.fieldPath.replace(/\.\$/g, '') };
+                                            }
+                                            else {
+                                                queryGroup_1[field.id] = { '$push': '$count_' + field.fieldPath.replace(/\.\$/g, '') };
+                                            }
+                                        }
+                                        else if (field.leafValueType === 'Minimum') {
+                                            queryGroup_1[field.id] = { '$min': '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Maximum') {
+                                            queryGroup_1[field.id] = { '$max': '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'First' || (!groupsRow.length && (!field.fieldPath.includes('.$') || field.fieldPath.includes('(Lookup)')))) {
+                                            queryGroup_1[field.id] = { '$first': '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Last') {
+                                            queryGroup_1[field.id] = { '$last': '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Unique') {
+                                            queryGroup_1[field.id] = { '$addToSet': '$' + field.fieldPath.replace(/\.\$/g, '') };
                                         }
                                         else {
-                                            condCheck.push({ $eq: [field.value, 0] });
-                                            condCheck.push({ $eq: [field.value, null] });
+                                            queryGroup_1[field.id] = { '$push': '$' + field.fieldPath.replace(/\.\$/g, '') };
                                         }
                                     });
-                                    if (opIndex > 0) {
-                                        condCheck.push({ $eq: ['$' + cust.selFieldId, 0] });
-                                        condCheck.push({ $eq: ['$' + cust.selFieldId, null] });
-                                    }
-                                    let tmpOperationFields = [];
-                                    if (opIndex > 0) {
-                                        tmpOperationFields.push('$' + cust.selFieldId);
-                                    }
-                                    operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-                                        if (field.field) {
-                                            tmpOperationFields.push('$' + field.field.replace(/\.\$/g, ''));
+                                    customFields.forEach(function (cust) {
+                                        if (cust.leafValueType === 'Average') {
+                                            queryGroup_1[cust.selFieldId] = { '$avg': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Sum') {
+                                            queryGroup_1[cust.selFieldId] = { '$sum': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Count') {
+                                            if (reportType === 'Dated') {
+                                                queryGroup_1[cust.selFieldId] = { '$sum': '$count_' + cust.selFieldId };
+                                            }
+                                            else {
+                                                queryGroup_1[cust.selFieldId] = { '$push': '$count_' + cust.selFieldId };
+                                            }
+                                        }
+                                        else if (cust.leafValueType === 'Minimum') {
+                                            queryGroup_1[cust.selFieldId] = { '$min': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Maximum') {
+                                            queryGroup_1[cust.selFieldId] = { '$max': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'First') {
+                                            queryGroup_1[cust.selFieldId] = { '$first': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Last') {
+                                            queryGroup_1[cust.selFieldId] = { '$last': '$' + cust.selFieldId };
+                                        }
+                                        else if (cust.leafValueType === 'Unique') {
+                                            queryGroup_1[cust.selFieldId] = { '$addToSet': '$' + cust.selFieldId };
                                         }
                                         else {
-                                            tmpOperationFields.push(field.value);
+                                            queryGroup_1[cust.selFieldId] = { '$push': '$' + cust.selFieldId };
                                         }
                                     });
-                                    custFieldGroup[cust.selFieldId] = {
-                                        $cond: { if: { $or: condCheck }, then: 0, else: { ['$' + operation.operation]: tmpOperationFields } }
-                                    };
+                                    // Totals
+                                    if (fieldsTotal.length) {
+                                        fieldsTotal.forEach(function (total) {
+                                            selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                                queryGroup_1[total.id + '_' + field.id] = { $sum: '$' + total.id + '_' + field.id };
+                                            });
+                                            customFields.forEach(function (field) {
+                                                queryGroup_1[total.id + '_' + field.selFieldId] = { $sum: '$' + total.id + '_' + field.selFieldId };
+                                            });
+                                        });
+                                    }
+                                    query_1.push({ $group: queryGroup_1 });
                                 }
                                 else {
-                                    custFieldGroup[cust.selFieldId] = {
-                                        ['$' + operation.operation]: []
+                                    queryProjection_1 = {
+                                        _id: 1
                                     };
-                                    if (opIndex > 0) {
-                                        custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $eq: ['$' + cust.selFieldId, null] }, then: 0, else: '$' + cust.selFieldId } });
-                                    }
-                                    let condOr = [];
-                                    operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-                                        if (field.field) {
-                                            condOr.push({ $eq: ['$' + field.field.replace(/\.\$/g, ''), null] });
+                                    selectedFields.forEach(function (field) {
+                                        if (field.leafValueType === 'Average') {
+                                            queryProjection_1[field.id] = { $avg: '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Sum') {
+                                            queryProjection_1[field.id] = { $sum: '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Count') {
+                                            queryProjection_1[field.id] = { $sum: 1 };
+                                        }
+                                        else if (field.leafValueType === 'Minimum') {
+                                            queryProjection_1[field.id] = { $min: '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                        }
+                                        else if (field.leafValueType === 'Maximum') {
+                                            queryProjection_1[field.id] = { $max: '$' + field.fieldPath.replace(/\.\$/g, '') };
                                         }
                                         else {
-                                            condOr.push({ $eq: [field.value, null] });
+                                            queryProjection_1[field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
                                         }
                                     });
-                                    operation.fields.filter(a => a.field || a.value !== null).forEach(field => {
-                                        if (field.field) {
-                                            custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $or: condOr }, then: 0, else: '$' + field.field.replace(/\.\$/g, '') } });
+                                    customFields.forEach(function (cust) {
+                                        if (cust === 'Average') {
+                                            queryProjection_1[cust.selFieldId] = { $avg: '$' + cust.selFieldId };
+                                        }
+                                        else if (cust === 'Sum') {
+                                            queryProjection_1[cust.selFieldId] = { $sum: '$' + cust.selFieldId };
+                                        }
+                                        else if (cust === 'Count') {
+                                            queryProjection_1[cust.selFieldId] = { $sum: 1 };
+                                        }
+                                        else if (cust === 'Minimum') {
+                                            queryProjection_1[cust.selFieldId] = { $min: '$' + cust.selFieldId };
+                                        }
+                                        else if (cust === 'Maximum') {
+                                            queryProjection_1[cust.selFieldId] = { $max: '$' + cust.selFieldId };
                                         }
                                         else {
-                                            custFieldGroup[cust.selFieldId]['$' + operation.operation].push({ $cond: { if: { $or: condOr }, then: 0, else: field.value } });
+                                            queryProjection_1[cust.selFieldId] = '$' + cust.selFieldId;
                                         }
                                     });
-                                }
-                                query.push({ $addFields: custFieldGroup });
-                            });
-                        });
-                        fieldsTotal.forEach(total => {
-                            customFields.forEach(field => {
-                                query.push({ $addFields: { [total.id + '_' + field.selFieldId]: '$' + field.selFieldId } });
-                            });
-                        });
-                        // Filters - Lookups / Arrays
-                        let queryMatchConditionLookup = {
-                            $and: []
-                        };
-                        if (filters.filter(a => (!a['$or'] && Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).length) {
-                            filters.filter(a => (!a['$or'] && Object.keys(a).some(b => b.includes('(Lookup)'))) || (a['$or'] && a['$or'].some(b => Object.keys(b).some(c => c.includes('(Lookup)'))))).forEach(filter => {
-                                queryMatchConditionLookup['$and'].push(filter);
-                            });
-                        }
-                        filterArrays.forEach(filter => {
-                            queryMatchConditionLookup['$and'].push(filter);
-                        });
-                        if (queryMatchConditionLookup.$and.length) {
-                            query.push({ $match: queryMatchConditionLookup });
-                        }
-                        // Group
-                        let queryGroup = {
-                            _id: {}
-                        };
-                        if (groupsRow.length || !displayType || displayType === 'grouped') {
-                            if (!groupsRow.length) {
-                                queryGroup._id = '$_id';
-                            }
-                            groupsRow.forEach(row => {
-                                queryGroup._id[row.id] = '$' + row.field.replace(/\.\$/g, '');
-                                if (date_field && date_interval) {
-                                    if (date_interval === 'Daily') {
-                                        queryGroup._id['day'] = { '$dayOfMonth': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                        queryGroup._id['month'] = { '$month': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                        queryGroup._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                    }
-                                    else if (date_interval === 'Weekly') {
-                                        queryGroup._id['week'] = { '$isoWeek': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                        queryGroup._id['year'] = { '$isoWeekYear': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                    }
-                                    else if (date_interval === 'Monthly') {
-                                        queryGroup._id['month'] = { '$month': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                        queryGroup._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                    }
-                                    else if (date_interval === 'Quarterly') {
-                                        queryGroup._id['month'] = { '$month': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                        queryGroup._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
+                                    //Totals
+                                    if (fieldsTotal.length && (reportType === 'List' || reportType === 'Dated')) {
+                                        fieldsTotal.forEach(function (total) {
+                                            selectedFields.filter(function (a) { return a.fieldType === 'Number' || a.leafValueType === 'Count'; }).forEach(function (field) {
+                                                var _a;
+                                                queryProjection_1[total.id + '_' + field.id] = (_a = {}, _a['$' + total.type] = '$' + total.id + '_' + field.id, _a);
+                                            });
+                                            customFields.forEach(function (field) {
+                                                var _a;
+                                                queryProjection_1[total.id + '_' + field.selFieldId] = (_a = {}, _a['$' + total.type] = '$' + total.id + '_' + field.selFieldId, _a);
+                                            });
+                                        });
                                     }
-                                    else if (date_interval === 'Yearly') {
-                                        queryGroup._id['year'] = { '$year': { 'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': this.serverConfig['TIMEZONE'] } };
-                                    }
-                                }
-                            });
-                            selectedFields.forEach(field => {
-                                if (field.leafValueType === 'Average') {
-                                    queryGroup[field.id] = { '$avg': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Sum') {
-                                    queryGroup[field.id] = { '$sum': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Count') {
-                                    if (reportType === 'Dated') {
-                                        queryGroup[field.id] = { '$sum': '$count_' + field.fieldPath.replace(/\.\$/g, '') };
-                                    }
-                                    else {
-                                        queryGroup[field.id] = { '$push': '$count_' + field.fieldPath.replace(/\.\$/g, '') };
-                                    }
-                                }
-                                else if (field.leafValueType === 'Minimum') {
-                                    queryGroup[field.id] = { '$min': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Maximum') {
-                                    queryGroup[field.id] = { '$max': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'First' || (!groupsRow.length && (!field.fieldPath.includes('.$') || field.fieldPath.includes('(Lookup)')))) {
-                                    queryGroup[field.id] = { '$first': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Last') {
-                                    queryGroup[field.id] = { '$last': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Unique') {
-                                    queryGroup[field.id] = { '$addToSet': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else {
-                                    queryGroup[field.id] = { '$push': '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                            });
-                            customFields.forEach(cust => {
-                                if (cust.leafValueType === 'Average') {
-                                    queryGroup[cust.selFieldId] = { '$avg': '$' + cust.selFieldId };
-                                }
-                                else if (cust.leafValueType === 'Sum') {
-                                    queryGroup[cust.selFieldId] = { '$sum': '$' + cust.selFieldId };
-                                }
-                                else if (cust.leafValueType === 'Count') {
-                                    if (reportType === 'Dated') {
-                                        queryGroup[cust.selFieldId] = { '$sum': '$count_' + cust.selFieldId };
-                                    }
-                                    else {
-                                        queryGroup[cust.selFieldId] = { '$push': '$count_' + cust.selFieldId };
-                                    }
-                                }
-                                else if (cust.leafValueType === 'Minimum') {
-                                    queryGroup[cust.selFieldId] = { '$min': '$' + cust.selFieldId };
-                                }
-                                else if (cust.leafValueType === 'Maximum') {
-                                    queryGroup[cust.selFieldId] = { '$max': '$' + cust.selFieldId };
-                                }
-                                else if (cust.leafValueType === 'First') {
-                                    queryGroup[cust.selFieldId] = { '$first': '$' + cust.selFieldId };
-                                }
-                                else if (cust.leafValueType === 'Last') {
-                                    queryGroup[cust.selFieldId] = { '$last': '$' + cust.selFieldId };
-                                }
-                                else if (cust.leafValueType === 'Unique') {
-                                    queryGroup[cust.selFieldId] = { '$addToSet': '$' + cust.selFieldId };
-                                }
-                                else {
-                                    queryGroup[cust.selFieldId] = { '$push': '$' + cust.selFieldId };
-                                }
-                            });
-                            // Totals
-                            if (fieldsTotal.length) {
-                                fieldsTotal.forEach(total => {
-                                    selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-                                        queryGroup[total.id + '_' + field.id] = { $sum: '$' + total.id + '_' + field.id };
-                                    });
-                                    customFields.forEach(field => {
-                                        queryGroup[total.id + '_' + field.selFieldId] = { $sum: '$' + total.id + '_' + field.selFieldId };
-                                    });
-                                });
-                            }
-                            query.push({ $group: queryGroup });
-                        }
-                        else {
-                            //Projection
-                            let queryProjection = {
-                                _id: 1
-                            };
-                            selectedFields.forEach(field => {
-                                if (field.leafValueType === 'Average') {
-                                    queryProjection[field.id] = { $avg: '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Sum') {
-                                    queryProjection[field.id] = { $sum: '$' + field.fieldPath.replace(/\.\$/g, '') };
+                                    query_1.push({ $project: queryProjection_1 });
                                 }
-                                else if (field.leafValueType === 'Count') {
-                                    queryProjection[field.id] = { $sum: 1 };
-                                }
-                                else if (field.leafValueType === 'Minimum') {
-                                    queryProjection[field.id] = { $min: '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else if (field.leafValueType === 'Maximum') {
-                                    queryProjection[field.id] = { $max: '$' + field.fieldPath.replace(/\.\$/g, '') };
-                                }
-                                else {
-                                    queryProjection[field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
-                                }
-                            });
-                            customFields.forEach(cust => {
-                                if (cust === 'Average') {
-                                    queryProjection[cust.selFieldId] = { $avg: '$' + cust.selFieldId };
-                                }
-                                else if (cust === 'Sum') {
-                                    queryProjection[cust.selFieldId] = { $sum: '$' + cust.selFieldId };
-                                }
-                                else if (cust === 'Count') {
-                                    queryProjection[cust.selFieldId] = { $sum: 1 };
-                                }
-                                else if (cust === 'Minimum') {
-                                    queryProjection[cust.selFieldId] = { $min: '$' + cust.selFieldId };
-                                }
-                                else if (cust === 'Maximum') {
-                                    queryProjection[cust.selFieldId] = { $max: '$' + cust.selFieldId };
-                                }
-                                else {
-                                    queryProjection[cust.selFieldId] = '$' + cust.selFieldId;
-                                }
-                            });
-                            //Totals
-                            if (fieldsTotal.length && (reportType === 'List' || reportType === 'Dated')) {
-                                fieldsTotal.forEach(total => {
-                                    selectedFields.filter(a => a.fieldType === 'Number' || a.leafValueType === 'Count').forEach(field => {
-                                        queryProjection[total.id + '_' + field.id] = { ['$' + total.type]: '$' + total.id + '_' + field.id };
-                                    });
-                                    customFields.forEach(field => {
-                                        queryProjection[total.id + '_' + field.selFieldId] = { ['$' + total.type]: '$' + total.id + '_' + field.selFieldId };
-                                    });
-                                });
-                            }
-                            query.push({ $project: queryProjection });
-                        }
-                        // SORT
-                        if (rootOptions.sort) {
-                            query.push({
-                                $sort: rootOptions.sort
-                            });
-                        }
-                        if (reportType === 'Group' && groupsRow.length > 1) {
-                            for (let i = groupsRow.length - 1; i >= 1; i--) {
-                                let projQuery = { _id: 1 };
-                                projQuery[groupsRow[i].id] = {
-                                    _id: { [groupsRow[i].id]: '$_id.' + groupsRow[i].id }
-                                };
-                                if (i === groupsRow.length - 1) {
-                                    selectedFields.forEach(field => {
-                                        projQuery[groupsRow[i].id][field.id] = '$' + field.id;
-                                    });
-                                    customFields.forEach(field => {
-                                        projQuery[groupsRow[i].id][field.selFieldId] = '$' + field.selFieldId;
-                                    });
-                                }
-                                else {
-                                    projQuery[groupsRow[i].id][groupsRow[i + 1].id] = '$' + groupsRow[i + 1].id;
-                                }
-                                fieldsTotal.forEach(totField => {
-                                    selectedFields.filter(b => b.fieldType === 'Number' || b.leafValueType === 'Count').forEach(selField => {
-                                        projQuery[totField.id + '_' + selField.id] = 1;
-                                        projQuery[groupsRow[i].id][totField.id + '_' + selField.id] = '$' + totField.id + '_' + selField.id;
-                                    });
-                                    customFields.forEach(field => {
-                                        projQuery[groupsRow[i].id][totField.id + '_' + field.selFieldId] = '$' + totField.id + '_' + field.selFieldId;
+                                // SORT
+                                if (rootOptions.sort) {
+                                    query_1.push({
+                                        $sort: rootOptions.sort
                                     });
-                                });
-                                query.push({ $project: projQuery });
-                                let grQuery = {
-                                    _id: {}
-                                };
-                                for (let j = 0; j < i; j++) {
-                                    grQuery._id[groupsRow[j].id] = '$_id.' + groupsRow[j].id;
                                 }
-                                grQuery[groupsRow[i].id] = {
-                                    $push: '$' + groupsRow[i].id
-                                };
-                                fieldsTotal.forEach(totField => {
-                                    selectedFields.filter(b => b.fieldType === 'Number' || b.leafValueType === 'Count').forEach(selField => {
-                                        grQuery[totField.id + '_' + selField.id] = { ['$' + totField.type]: '$' + totField.id + '_' + selField.id };
-                                    });
-                                    customFields.forEach(field => {
-                                        grQuery[totField.id + '_' + field.selFieldId] = { ['$' + totField.type]: '$' + totField.id + '_' + field.selFieldId };
-                                    });
-                                });
-                                query.push({ $group: grQuery });
-                                if (rootOptions.sort) {
-                                    let sortKeys = Object.keys(rootOptions.sort);
-                                    let sort = {};
-                                    let groupString = '';
-                                    groupsRow.forEach((row, groupIndex) => {
-                                        if (groupIndex > 0) {
-                                            groupString += 'gr_' + (groupIndex + 1) + '.';
-                                        }
-                                        if (sortKeys.includes('_id.gr_' + (groupIndex + 1))) {
-                                            sort[groupString + '_id.gr_' + (groupIndex + 1)] = rootOptions.sort['_id.gr_' + (groupIndex + 1)];
+                                if (reportType === 'Group' && groupsRow.length > 1) {
+                                    _loop_1 = function (i) {
+                                        var _a;
+                                        var projQuery = { _id: 1 };
+                                        projQuery[groupsRow[i].id] = {
+                                            _id: (_a = {}, _a[groupsRow[i].id] = '$_id.' + groupsRow[i].id, _a)
+                                        };
+                                        if (i === groupsRow.length - 1) {
+                                            selectedFields.forEach(function (field) {
+                                                projQuery[groupsRow[i].id][field.id] = '$' + field.id;
+                                            });
+                                            customFields.forEach(function (field) {
+                                                projQuery[groupsRow[i].id][field.selFieldId] = '$' + field.selFieldId;
+                                            });
                                         }
                                         else {
-                                            sort[groupString + '_id.gr_' + (groupIndex + 1)] = 1;
+                                            projQuery[groupsRow[i].id][groupsRow[i + 1].id] = '$' + groupsRow[i + 1].id;
                                         }
+                                        fieldsTotal.forEach(function (totField) {
+                                            selectedFields.filter(function (b) { return b.fieldType === 'Number' || b.leafValueType === 'Count'; }).forEach(function (selField) {
+                                                projQuery[totField.id + '_' + selField.id] = 1;
+                                                projQuery[groupsRow[i].id][totField.id + '_' + selField.id] = '$' + totField.id + '_' + selField.id;
+                                            });
+                                            customFields.forEach(function (field) {
+                                                projQuery[groupsRow[i].id][totField.id + '_' + field.selFieldId] = '$' + totField.id + '_' + field.selFieldId;
+                                            });
+                                        });
+                                        query_1.push({ $project: projQuery });
+                                        var grQuery = {
+                                            _id: {}
+                                        };
+                                        for (var j = 0; j < i; j++) {
+                                            grQuery._id[groupsRow[j].id] = '$_id.' + groupsRow[j].id;
+                                        }
+                                        grQuery[groupsRow[i].id] = {
+                                            $push: '$' + groupsRow[i].id
+                                        };
+                                        fieldsTotal.forEach(function (totField) {
+                                            selectedFields.filter(function (b) { return b.fieldType === 'Number' || b.leafValueType === 'Count'; }).forEach(function (selField) {
+                                                var _a;
+                                                grQuery[totField.id + '_' + selField.id] = (_a = {}, _a['$' + totField.type] = '$' + totField.id + '_' + selField.id, _a);
+                                            });
+                                            customFields.forEach(function (field) {
+                                                var _a;
+                                                grQuery[totField.id + '_' + field.selFieldId] = (_a = {}, _a['$' + totField.type] = '$' + totField.id + '_' + field.selFieldId, _a);
+                                            });
+                                        });
+                                        query_1.push({ $group: grQuery });
+                                        if (rootOptions.sort) {
+                                            var sortKeys_1 = Object.keys(rootOptions.sort);
+                                            var sort_1 = {};
+                                            var groupString_1 = '';
+                                            groupsRow.forEach(function (row, groupIndex) {
+                                                if (groupIndex > 0) {
+                                                    groupString_1 += 'gr_' + (groupIndex + 1) + '.';
+                                                }
+                                                if (sortKeys_1.includes('_id.gr_' + (groupIndex + 1))) {
+                                                    sort_1[groupString_1 + '_id.gr_' + (groupIndex + 1)] = rootOptions.sort['_id.gr_' + (groupIndex + 1)];
+                                                }
+                                                else {
+                                                    sort_1[groupString_1 + '_id.gr_' + (groupIndex + 1)] = 1;
+                                                }
+                                            });
+                                            sortKeys_1.filter(function (a) { return !a.startsWith('_id.gr_'); }).forEach(function (key) {
+                                                sort_1[groupString_1 + key] = rootOptions.sort[key];
+                                            });
+                                            query_1.push({ $sort: sort_1 });
+                                        }
+                                    };
+                                    for (i = groupsRow.length - 1; i >= 1; i--) {
+                                        _loop_1(i);
+                                    }
+                                }
+                                res_1 = null;
+                                _a.label = 2;
+                            case 2:
+                                _a.trys.push([2, 4, , 5]);
+                                return [4 /*yield*/, modelCollection.aggregate(query_1, { allowDiskUse: true })];
+                            case 3:
+                                res_1 = _a.sent();
+                                return [3 /*break*/, 5];
+                            case 4:
+                                err_1 = _a.sent();
+                                console.log(err_1);
+                                return [3 /*break*/, 5];
+                            case 5:
+                                tmpTotals_1 = {};
+                                if (res_1) {
+                                    fieldsTotal.forEach(function (totField) {
+                                        selectedFields.filter(function (b) { return b.fieldType === 'Number' || b.leafValueType === 'Count'; }).forEach(function (selField) {
+                                            if (totField.type === 'sum') {
+                                                tmpTotals_1[totField.id + '_' + selField.id] = res_1.map(function (a) { return a[totField.id + '_' + selField.id] || 0; }).reduce(function (a, b) { return a + b; }, 0);
+                                            }
+                                            else if (totField.type === 'avg') {
+                                                tmpTotals_1[totField.id + '_' + selField.id] = Math.round(res_1.map(function (a) { return a[totField.id + '_' + selField.id] || 0; }).reduce(function (a, b) { return a + b; }, 0) / res_1.length);
+                                            }
+                                        });
+                                        customFields.forEach(function (custField) {
+                                            if (totField.type === 'sum') {
+                                                tmpTotals_1[totField.id + '_' + custField.selFieldId] = res_1.map(function (a) { return a[totField.id + '_' + custField.selFieldId] || 0; }).reduce(function (a, b) { return a + b; }, 0);
+                                            }
+                                            else if (totField.type === 'avg') {
+                                                tmpTotals_1[totField.id + '_' + custField.selFieldId] = Math.round(res_1.map(function (a) { return a[totField.id + '_' + custField.selFieldId] || 0; }).reduce(function (a, b) { return a + b; }, 0) / res_1.length);
+                                            }
+                                        });
                                     });
-                                    sortKeys.filter(a => !a.startsWith('_id.gr_')).forEach(key => {
-                                        sort[groupString + key] = rootOptions.sort[key];
-                                    });
-                                    query.push({ $sort: sort });
                                 }
-                            }
-                        }
-                        // console.log('_____________ query __________'); console.log(query); console.log(JSON.stringify(query, null, 2));
-                        let res = null;
-                        try {
-                            res = await modelCollection.aggregate(query, { allowDiskUse: true });
-                        }
-                        catch (err) {
-                            console.log(err);
-                        }
-                        let tmpTotals = {};
-                        if (res) {
-                            fieldsTotal.forEach(totField => {
-                                selectedFields.filter(b => b.fieldType === 'Number' || b.leafValueType === 'Count').forEach(selField => {
-                                    if (totField.type === 'sum') {
-                                        tmpTotals[totField.id + '_' + selField.id] = res.map(a => a[totField.id + '_' + selField.id] || 0).reduce((a, b) => a + b, 0);
-                                    }
-                                    else if (totField.type === 'avg') {
-                                        tmpTotals[totField.id + '_' + selField.id] = Math.round(res.map(a => a[totField.id + '_' + selField.id] || 0).reduce((a, b) => a + b, 0) / res.length);
-                                    }
-                                });
-                                customFields.forEach(custField => {
-                                    if (totField.type === 'sum') {
-                                        tmpTotals[totField.id + '_' + custField.selFieldId] = res.map(a => a[totField.id + '_' + custField.selFieldId] || 0).reduce((a, b) => a + b, 0);
-                                    }
-                                    else if (totField.type === 'avg') {
-                                        tmpTotals[totField.id + '_' + custField.selFieldId] = Math.round(res.map(a => a[totField.id + '_' + custField.selFieldId] || 0).reduce((a, b) => a + b, 0) / res.length);
-                                    }
-                                });
-                            });
+                                tmpRes = [{
+                                        count: res_1 ? res_1.length : 0,
+                                        results: res_1 ? (rootOptions.limit ? res_1.splice(0, rootOptions.limit) : res_1) : [],
+                                        totals: tmpTotals_1
+                                    }];
+                                resolve(tmpRes);
+                                _a.label = 6;
+                            case 6: return [2 /*return*/];
                         }
-                        let tmpRes = [{
-                                count: res ? res.length : 0,
-                                results: res ? (rootOptions.limit ? res.splice(0, rootOptions.limit) : res) : [],
-                                totals: tmpTotals
-                            }];
-                        resolve(tmpRes);
-                    }
-                });
+                    });
+                }); });
             },
         }
     });
 }
+exports.loadReportBuilderMethods = loadReportBuilderMethods;
 
 //# sourceMappingURL=report-builder.js.map