@resolveio/server-lib 12.5.52 → 12.5.54

package/src/methods/report-builder.ts

@@ -0,0 +1,876 @@
+import SimpleSchema from 'simpl-schema';
+import { MethodManager } from '../managers/method.manager';
+import { PaginationOptions, PaginationOptionsSchema } from '../models/pagination.model';
+import { ResolveIOServer } from '../index';
+import { getReportLookupSchemas, buildTree, mongoCommand } from '../util/schema-report-builder';
+
+export function loadReportBuilderMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		reportBuilderBuildTree: {
+			check: new SimpleSchema({
+				collection_root: {
+					type: String
+				}
+			}),
+			function: function(collection_root: string) {
+				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];
+							}
+						});
+						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});
+				});
+			}
+		},
+		reportBuilderGetDistinctValue: {
+			check: new SimpleSchema({
+				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, '')));
+						}
+					}
+					else {
+						resolve([]);
+					}
+				});
+			}
+		},
+		reportBuilderGetResults: {
+			check: new SimpleSchema({
+				reportType: {
+					type: String
+				},
+				rootCollectionName: {
+					type: String
+				},
+				options: {
+					type: PaginationOptionsSchema
+				},
+				filters: {
+					type: Array,
+					optional: true
+				},
+				'filters.$': {
+					type: Object,
+					blackbox: true,
+					optional: true
+				},
+				filterArrays: {
+					type: Array,
+					optional: true
+				},
+				'filterArrays.$': {
+					type: Object,
+					blackbox: true,
+					optional: true
+				},
+				filterArrayFields: {
+					type: Array,
+					optional: true
+				},
+				'filterArrayFields.$': {
+					type: Object,
+					blackbox: true,
+					optional: true
+				},
+				selectedFields: {
+					type: Array,
+					optional: true
+				},
+				'selectedFields.$': {
+					type: Object,
+					optional: true,
+					blackbox: true
+				},
+				customFields: {
+					type: Array,
+					optional: true
+				},
+				'customFields.$': {
+					type: Object,
+					optional: true,
+					blackbox: true
+				},
+				groupsRow: {
+					type: Array
+				},
+				'groupsRow.$': {
+					type: Object,
+					blackbox: true
+				},
+				fieldsTotal: {
+					type: Array
+				},
+				'fieldsTotal.$': {
+					type: Object,
+					blackbox: true
+				},
+				fieldsLink: {
+					type: Array
+				},
+				'fieldsLink.$': {
+					type: Object,
+					blackbox: true
+				},
+				date_field: {
+					type: String,
+					optional: true
+				},
+				date_interval: {
+					type: String,
+					optional: true
+				},
+				displayType: {
+					type: String,
+					optional: true
+				}
+			}),
+			function: function(reportType: string, rootCollectionName: string, rootOptions: PaginationOptions, filters: any[] = [], filterArrays: any[] = [], filterArrayFields: any[] = [], selectedFields: any[] = [], customFields: any[] = [], groupsRow: any[] = [], fieldsTotal: any[] = [], fieldsLink: any[] = [], 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}});
+									}
+								}
+								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}});
+									}
+								}
+							}
+						});
+
+						// 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}});
+										}
+									}
+									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}});
+										}
+									}
+								}
+							}
+						});
+
+						// 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}});
+										}
+										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}});
+												}
+											}
+										}
+									}
+									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, []]}}}});
+										}
+
+										if (field.leafValueType !== 'Count' && !query.some(a => a.$unwind && a.$unwind.path === '$' + fieldPath)) {
+											query.push({'$unwind': {path: '$' + fieldPath, preserveNullAndEmptyArrays: true}});
+										}
+									}
+								}
+							}
+						});
+
+						// 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 => {
+										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] = {
+											$divide: ['$' + field.fieldPath.replace(/\.\$/g, ''), {$multiply: multFields}]
+										};	
+									}
+								}
+								else {
+									if (field.leafValueType === 'Count') {
+										divFields.$addFields[total.id + '_' + field.id] = '$count';
+									}
+									else {
+										divFields.$addFields[total.id + '_' + field.id] = '$' + field.fieldPath.replace(/\.\$/g, '');
+									}
+								}
+							});
+						});
+
+						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}]
+								};
+							}
+							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;
+									});
+								}
+								else {
+									divFields.$addFields['count_' + field.fieldPath.replace(/\.\$/g, '')] = '$count';
+								}
+							}
+						});
+
+						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]});
+										}
+										else {
+											condCheck.push({$eq: [field.value, 0]});
+											condCheck.push({$eq: [field.value, null]});
+										}
+									});
+
+									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, ''));
+										}
+										else {
+											tmpOperationFields.push(field.value);
+										}
+									});
+
+									custFieldGroup[cust.selFieldId] = {
+										$cond: { if: { $or: condCheck }, then: 0, else: {['$' + operation.operation]: tmpOperationFields} }
+									};
+								}
+								else {
+									custFieldGroup[cust.selFieldId] = {
+										['$' + operation.operation]: []
+									};
+
+									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]});
+										}
+										else {
+											condOr.push({$eq: [field.value, null]});
+										}
+									});
+		
+									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, '')}});
+										}
+										else {
+											custFieldGroup[cust.selFieldId]['$' + operation.operation].push({$cond: { if: { $or: condOr }, then: 0, else: field.value}});
+										}
+									});
+								}
+
+								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';
+							}
+							else {
+								if (rootOptions.sort) { 
+									let groupedSorts = {};
+									Object.keys(rootOptions.sort).forEach(sortField => {
+										let selField = selectedFields.filter(a => a.id === sortField)[0];
+
+										if (selField) {
+											groupedSorts[selField.fieldPath.replace(/\.\$/g, '')] = rootOptions.sort[sortField];
+										}
+									});
+									if (Object.keys(groupedSorts).length > 0) {
+										query.push({
+											$sort: groupedSorts
+										});
+									}
+								}
+							}
+
+							groupsRow.forEach(row => {
+								queryGroup._id[row.id] = '$' + row.field.replace(/\.\$/g, '');
+
+								if (date_field && date_interval) {
+									if (date_interval === 'Seconds') {
+										queryGroup._id['second'] = {'$second' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['minute'] = {'$minute' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['hour'] = {'$hour' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['day'] = {'$dayOfMonth' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['month'] = {'$month' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Minutes') {
+										queryGroup._id['minute'] = {'$minute' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['hour'] = {'$hour' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['day'] = {'$dayOfMonth' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['month'] = {'$month' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Hours') {
+										queryGroup._id['hour'] = {'$hour' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['day'] = {'$dayOfMonth' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['month'] = {'$month' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Daily') {
+										queryGroup._id['day'] = {'$dayOfMonth' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['month'] = {'$month' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Weekly') {
+										queryGroup._id['week'] = {'$isoWeek' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$isoWeekYear' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Monthly') {
+										queryGroup._id['month'] = {'$month' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Quarterly') {
+										queryGroup._id['month'] = {'$month' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+									else if (date_interval === 'Yearly') {
+										queryGroup._id['year'] = {'$year' : {'date': '$' + date_field.replace(/\.\$/g, ''), 'timezone': process.env.TZ}};
+									}
+								}
+							});
+
+							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') {
+									queryGroup[field.id] = { '$sum': '$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': {$ifNull: ['$' + field.fieldPath.replace(/\.\$/g, ''), null]}};
+								}
+							});
+
+							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': {$ifNull: ['$' +  cust.selFieldId, null]}};
+								}
+							});
+
+							// 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, '')};
+								}
+								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;
+									});
+								});
+
+								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)];
+										}
+										else {
+											sort[groupString + '_id.gr_' + (groupIndex + 1)] = 1;
+										}
+									});
+
+									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, readPreference: this.serverConfig['ROOT_URL'] !== 'http://localhost:4200' ? 'secondary' : 'primary'}, 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);
+									}
+								});
+							});
+						}
+
+						let tmpRes = [{
+							count: res ? res.length : 0,
+							results: res ? (rootOptions.limit ? res.splice(0, rootOptions.limit) : res) : [],
+							totals: tmpTotals
+						}];
+
+						resolve(tmpRes);
+					}
+				});
+			},
+		}
+	});
+}