@resolveio/server-lib 22.3.125 → 22.3.126

package/src/methods/cron-jobs.ts

@@ -0,0 +1,2614 @@
+import axios from 'axios';
+import * as Excel from 'exceljs';
+import * as moment from 'moment-timezone';
+import SimpleSchema from 'simpl-schema';
+import { CronJobs } from '../collections/cron-job.collection';
+import { CommunicationMetrics } from '../collections/communication-metric.collection';
+import { Files } from '../collections/file.collection';
+import { OpenAIUsageLedger } from '../collections/openai-usage-ledger.collection';
+import { ReportBuilderReports } from '../collections/report-builder-report.collection';
+import { MethodManager } from '../managers/method.manager';
+import { PaginationOptions } from '../models/pagination.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+import { deepCopy, mergeDeep, round, toTitleCase } from '../util/common';
+
+function getFilterTargets(fieldPath: string, report: any): string[] {
+	if (!fieldPath) {
+		return [];
+	}
+
+	if (fieldPath.startsWith('layout_col_')) {
+		const normalized = fieldPath.replace(/^layout_col_/, '');
+		const parts = normalized.split('_');
+		const idx = parseInt(parts[parts.length - 1], 10);
+
+		if (!isNaN(idx)) {
+			const layoutTargets = (report?.fields_selected || [])
+				.filter(f => f && (f.layoutColumnIndex === idx || (f.id || '').includes(`f_layout_${idx}_`)))
+				.map(f => f.fieldPath);
+
+			if (layoutTargets.length) {
+				return layoutTargets;
+			}
+		}
+	}
+
+	return [fieldPath];
+}
+
+function buildFilterExpression(filter: any, path: string) {
+	if (!filter || !filter.condition || (!filter.field && !path)) {
+		return null;
+	}
+
+	const hasValue = filter.value !== null && (Array.isArray(filter.value) ? filter.value.length > 0 : true);
+
+	if (!hasValue && filter.condition !== 'null' && filter.condition !== 'nnull') {
+		return null;
+	}
+
+	if (filter.condition === 'bw') {
+		if (filter.fieldType === 'Date' && filter.is_rolling) {
+			let startDate = null;
+			let endDate = null;
+
+			if (filter.rolling_interval === 'Q1') {
+				startDate = moment().startOf('year').toDate();
+				endDate = moment().startOf('year').quarter(2).subtract(1, 'days').toDate();
+			}
+			else if (filter.rolling_interval === 'Q2') {
+				startDate = moment().startOf('year').quarter(2).toDate();
+				endDate = moment().startOf('year').quarter(3).subtract(1, 'days').toDate();
+			}
+			else if (filter.rolling_interval === 'Q3') {
+				startDate = moment().startOf('year').quarter(3).toDate();
+				endDate = moment().startOf('year').quarter(4).subtract(1, 'days').toDate();
+			}
+			else if (filter.rolling_interval === 'Q4') {
+				startDate = moment().startOf('year').quarter(4).toDate();
+				endDate = moment().endOf('year').toDate();
+			}
+			else if (filter.rolling_interval === 'Today') {
+				startDate = moment().startOf('day').toDate();
+				endDate = moment().endOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Yesterday') {
+				startDate = moment().subtract(1, 'days').startOf('day').toDate();
+				endDate = moment().subtract(1, 'days').endOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Week') {
+				startDate = moment().startOf('isoWeek').toDate();
+				endDate = moment().endOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Last Week') {
+				endDate = moment().startOf('isoWeek').subtract(1, 'days').toDate();
+				startDate = moment(endDate).startOf('isoWeek').toDate();
+			}
+			else if (filter.rolling_interval === 'Month') {
+				startDate = moment().startOf('month').toDate();
+				endDate = moment().endOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Last Month') {
+				endDate = moment().startOf('month').subtract(1, 'days').endOf('day').toDate();
+				startDate = moment(endDate).startOf('month').toDate();
+			}
+			else if (filter.rolling_interval === 'Last 30 Days') {
+				endDate = moment().endOf('day').toDate();
+				startDate = moment().subtract(30, 'days').startOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Quarter') {
+				startDate = moment().startOf('year').quarter(moment().quarter()).toDate();
+				endDate = moment().endOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Last Quarter') {
+				endDate = moment().startOf('year').quarter(moment().quarter()).subtract(1, 'days').endOf('day').toDate();
+				startDate = moment(endDate).startOf('quarter').toDate();
+			}
+			else if (filter.rolling_interval === 'Year') {
+				startDate = moment().startOf('year').toDate();
+				endDate = moment().endOf('day').toDate();
+			}
+			else if (filter.rolling_interval === 'Last Year') {
+				endDate = moment().startOf('year').subtract(1, 'days').endOf('day').toDate();
+				startDate = moment(endDate).startOf('year').toDate();
+			}
+			else if (filter.rolling_interval === 'All') {
+				startDate = new Date(2017, 0, 1, 0, 0, 0, 0);
+				endDate = moment().endOf('day').toDate();
+			}
+
+			return {$and: [{[path]: {'$gte': startDate}}, {[path]: {'$lte': endDate}}]};
+		}
+
+		return {$and: [{[path]: {'$gte': filter.value}}, {[path]: {'$lte': filter.highValue}}]};
+	}
+	else if (filter.condition === 'nnull') {
+		let and = [];
+		and.push({[path]: {'$exists': true}});
+		and.push({[path]: {'$ne': null}});
+
+		if (filter.fieldType === 'String') {
+			and.push({[path]: {'$ne': ''}});
+		}
+
+		return {$and: and};
+	}
+	else if (filter.condition === 'null') {
+		return {[path]: {'$eq': null}};
+	}
+	else {
+		if (Array.isArray(filter.value)) {
+			if (filter.condition === 'ne') {
+				let and = [];
+				filter.value.forEach(filt => {
+					and.push({[path]: {['$' + filter.condition]: (Array.isArray(filt) ? filt[0] : filt)}});
+				});
+
+				if (and.length > 1) {
+					return {$and: and};
+				}
+				else {
+					return and[0];
+				}
+			}
+			else {
+				let or = [];
+
+				filter.value.forEach(filt => {
+					or.push({[path]: {['$' + filter.condition]: (Array.isArray(filt) ? filt[0] : filt)}});
+				});
+
+				if (or.length > 1) {
+					return {$or: or};
+				}
+				else {
+					return or[0];
+				}
+			}
+		}
+		else {
+			return {[path]: {['$' + filter.condition]: filter.value}};
+		}
+	}
+
+	return null;
+}
+
+function parseLayoutColIndex(fieldRef: string): number | null {
+	if (!fieldRef || !fieldRef.startsWith('layout_col_')) {
+		return null;
+	}
+
+	const normalized = fieldRef.replace(/^layout_col_/, '');
+	const parts = normalized.split('_');
+	const idx = parseInt(parts[parts.length - 1], 10);
+
+	return isNaN(idx) ? null : idx;
+}
+
+function resolveLayoutColumnPrimaryLeafId(fieldRef: string, report: any) {
+	const idx = parseLayoutColIndex(fieldRef);
+
+	if (idx === null) {
+		return null;
+	}
+
+	const candidates = (report?.fields_selected || []).filter(f => f && typeof f.layoutColumnIndex !== 'undefined' && f.layoutColumnIndex === idx);
+
+	if (!candidates.length) {
+		return null;
+	}
+
+	const root = report?.collection_root;
+	const preferred = candidates.find(c => c.collection_name === root || c.layoutCollection === root) || candidates[0];
+
+	return preferred?.id || null;
+}
+
+function resolveFieldRefToLeafId(fieldRef: string, report: any) {
+	if (!fieldRef) {
+		return null;
+	}
+
+	if (fieldRef.startsWith('layout_col_')) {
+		return resolveLayoutColumnPrimaryLeafId(fieldRef, report);
+	}
+
+	return fieldRef;
+}
+
+function buildCollectionKeysFromReport(report: any): string[] {
+	const keys: string[] = [];
+
+	if (report?.collection_root) {
+		keys.push(report.collection_root);
+	}
+
+	(report?.collection_joins || []).forEach(join => {
+		if (!join) {
+			return;
+		}
+
+		const alias = (join.alias || '').trim();
+		if (alias && !keys.includes(alias)) {
+			keys.push(alias);
+		}
+		else if (join.collection && !keys.includes(join.collection)) {
+			keys.push(join.collection);
+		}
+	});
+
+	return keys.length ? keys : ['root'];
+}
+
+function buildLayoutColumnsFromFields(report: any, fields: any[] = []) {
+	const keys = buildCollectionKeysFromReport(report);
+
+	return (fields || []).map((field, index) => {
+		const header = field.columnName || field.fieldName || `Column ${index + 1}`;
+		const isCustom = ((field?.id || field?.fieldPath || '') + '').startsWith('c_') || field?.fieldPathName === 'Custom Field';
+
+		const mappings = keys.map(key => {
+			const matchesKey = key === report.collection_root
+				? (field.collection_name === report.collection_root || isCustom)
+				: (key === (field.lookup_as || '').trim()) || key === field.collection_name;
+
+			if (matchesKey) {
+				return {
+					collection: key,
+					mode: 'variable',
+					fieldPath: field.fieldPath || '',
+					fieldId: field.id || `f_layout_${index}`,
+					text: '',
+					leafValueType: field.leafValueType || 'Value',
+					leafFormatType: field.leafFormatType || ''
+				};
+			}
+
+			return {
+				collection: key,
+				mode: 'text',
+				fieldPath: '',
+				fieldId: '',
+				text: '',
+				leafValueType: 'Value',
+				leafFormatType: ''
+			};
+		});
+
+		return {
+			id: field.id ? `layout_${field.id}` : `layout_${index}`,
+			header,
+			mappings
+		};
+	});
+}
+
+function ensureLayoutHasCustomField(report: any, layout: any[] = [], customId: string, columnName?: string, leafValueType?: string) {
+	if (!layout || !customId) {
+		return;
+	}
+
+	const hasCustomField = (layout || []).some(col => (col?.mappings || []).some(m =>
+		m?.mode === 'variable' && (m.fieldId === customId || m.fieldPath === customId)
+	));
+	if (hasCustomField) {
+		return;
+	}
+
+	const keys = buildCollectionKeysFromReport(report);
+	const rootKey = report?.collection_root || '';
+	const header = columnName || customId;
+
+	const mappings = keys.map(key => {
+		if (key === rootKey) {
+			return {
+				collection: key,
+				mode: 'variable',
+				fieldPath: customId,
+				fieldId: customId,
+				text: '',
+				leafValueType: leafValueType || 'Value',
+				leafFormatType: 'Number'
+			};
+		}
+
+		return {
+			collection: key,
+			mode: 'text',
+			fieldPath: '',
+			fieldId: '',
+			text: '',
+			leafValueType: 'Value',
+			leafFormatType: ''
+		};
+	});
+
+	layout.push({
+		id: `layout_${customId}`,
+		header,
+		mappings
+	});
+}
+
+function ensureLayoutIncludesCustomFields(report: any, layout: any[] = []) {
+	const fieldsCustom = report?.fields_custom || [];
+	if (!fieldsCustom.length) {
+		return layout;
+	}
+
+	fieldsCustom.forEach(custom => {
+		ensureLayoutHasCustomField(report, layout, custom?.id, custom?.columnName, custom?.leafValueType);
+	});
+
+	return layout;
+}
+
+function getLayoutColumnsFromReport(report: any) {
+	let layout: any[] = [];
+
+	if (report?.fields_layout && report.fields_layout.length) {
+		layout = deepCopy(report.fields_layout);
+	}
+	else {
+		layout = buildLayoutColumnsFromFields(report, report?.fields_selected || []);
+	}
+
+	return ensureLayoutIncludesCustomFields(report, layout);
+}
+
+function syncSelectedFieldsFromLayout(report: any, layoutColumns: any[] = []) {
+	const fields: any[] = [];
+	const sourceFields = deepCopy(report?.fields_selected || []);
+	const byId = new Map<string, any>();
+	const byPath = new Map<string, any>();
+
+	sourceFields.forEach(f => {
+		if (f?.id) {
+			byId.set(f.id, f);
+		}
+		if (f?.fieldPath) {
+			byPath.set(f.fieldPath, f);
+		}
+	});
+
+	layoutColumns.forEach((col, colIndex) => {
+		(col.mappings || []).forEach((map, mapIndex) => {
+			if (map.mode === 'variable' && map.fieldPath) {
+				const baseField = byId.get(map.fieldId) || byPath.get(map.fieldPath);
+
+				if (!baseField) {
+					return;
+				}
+
+				const clone = deepCopy(baseField);
+				clone.columnName = col.header || baseField.columnName || baseField.fieldPathName || 'Column';
+				clone.show = (typeof map.show === 'boolean')
+					? map.show
+					: (typeof baseField.show === 'boolean' ? baseField.show : true);
+				clone.leafValueType = map.leafValueType || clone.leafValueType;
+				clone.leafFormatType = map.leafFormatType || clone.leafFormatType;
+				clone.id = map.fieldId || clone.id || `f_layout_${colIndex}_${mapIndex}`;
+				clone.layoutCollection = map.collection;
+				clone.layoutColumnIndex = colIndex;
+
+				if (!map.fieldId) {
+					map.fieldId = clone.id;
+				}
+
+				fields.push(clone);
+			}
+		});
+	});
+
+	return fields;
+}
+
+function materializeLayoutRow(report: any, layoutColumns: any[], selectedFields: any[], row: any) {
+	const materialized: any = {_id: row?._id};
+
+	const hasDataForCollection = (collection: string) => {
+		if (!collection) {
+			return false;
+		}
+
+		return (selectedFields || []).some(f =>
+			f.layoutCollection === collection &&
+			row &&
+			Object.prototype.hasOwnProperty.call(row, f.id) &&
+			row[f.id] !== undefined &&
+			row[f.id] !== null &&
+			row[f.id] !== ''
+		);
+	};
+
+	(layoutColumns || []).forEach((col, colIndex) => {
+		const values: any[] = [];
+
+		(col.mappings || []).forEach(map => {
+			if (map.mode === 'text' && map.text) {
+				if (hasDataForCollection(map.collection)) {
+					values.push({collection: map.collection, value: map.text});
+				}
+			}
+			else if (map.mode === 'variable' && map.fieldId && row && Object.prototype.hasOwnProperty.call(row, map.fieldId)) {
+				values.push({collection: map.collection, value: row[map.fieldId]});
+			}
+		});
+
+		materialized[colIndex] = values;
+	});
+
+	return materialized;
+}
+
+function getLayoutCellExportValue(report: any, layoutRow: any, colIndex: number) {
+	if (!layoutRow || layoutRow[colIndex] === undefined || layoutRow[colIndex] === null) {
+		return '';
+	}
+
+	const cellValues = Array.isArray(layoutRow[colIndex]) ? layoutRow[colIndex] : [layoutRow[colIndex]];
+	const filtered = cellValues.filter(v => v !== undefined && v !== null && v.value !== undefined && v.value !== null && v.value !== '');
+
+	if (!filtered.length) {
+		return '';
+	}
+
+	const rootCollection = report?.collection_root;
+	const preferred = filtered.find(v => v.collection === rootCollection) || filtered[0];
+	const value = preferred?.value;
+
+	if (value === undefined || value === null) {
+		return '';
+	}
+
+	if (Array.isArray(value)) {
+		return value;
+	}
+
+	return typeof value === 'string' ? value.trim().replace(/\t/g, '').replace(/\n/g, '') : value;
+}
+
+function getPrimaryFieldForLayoutColumn(col: any, selectedFields: any[]) {
+	if (!col?.mappings) {
+		return null;
+	}
+
+	const target = col.mappings.find(m => m.mode === 'variable' && m.fieldId);
+
+	if (!target) {
+		return null;
+	}
+
+	return (selectedFields || []).find(f => f.id === target.fieldId) || null;
+}
+
+const STRING_DATE_FORMATS = [
+	moment.ISO_8601,
+	'MM/DD/YYYY',
+	'M/D/YYYY',
+	'MM/DD/YYYY h:mm A',
+	'M/D/YYYY h:mm A',
+	'MM/DD/YYYY hh:mm A',
+	'M/D/YYYY hh:mm A',
+	'MM/DD/YYYY h:mm:ss A',
+	'M/D/YYYY h:mm:ss A',
+	'MM/DD/YYYY hh:mm:ss A',
+	'M/D/YYYY hh:mm:ss A',
+	'MM/DD/YYYY H:mm',
+	'M/D/YYYY H:mm',
+	'MM/DD/YYYY HH:mm',
+	'M/D/YYYY HH:mm',
+	'MM/DD/YYYY H:mm:ss',
+	'M/D/YYYY H:mm:ss',
+	'MM/DD/YYYY HH:mm:ss',
+	'M/D/YYYY HH:mm:ss'
+];
+
+function parseMoment(value: any) {
+	if (value === null || value === undefined) {
+		return null;
+	}
+
+	if (moment.isMoment(value)) {
+		return value;
+	}
+
+	if (value instanceof Date || typeof value === 'number') {
+		const m = moment(value);
+		return m.isValid() ? m : null;
+	}
+
+	if (typeof value === 'string' || value instanceof String) {
+		const str = `${value}`.trim();
+		if (!str) {
+			return null;
+		}
+
+		const m = moment(str, STRING_DATE_FORMATS, true);
+		if (m.isValid()) {
+			return m;
+		}
+
+		const loose = moment(str, STRING_DATE_FORMATS, false);
+		if (loose.isValid()) {
+			return loose;
+		}
+
+		const jsDateStr = str.replace(/\s*\([^)]*\)\s*$/, '');
+		const jsDate = moment(jsDateStr, 'ddd MMM DD YYYY HH:mm:ss [GMT]ZZ', true);
+		if (jsDate.isValid()) {
+			return jsDate;
+		}
+
+		if (/[T:\\/\\-]/.test(str) || /GMT|UTC/i.test(str)) {
+			const fallback = moment(str);
+			return fallback.isValid() ? fallback : null;
+		}
+
+		return null;
+	}
+
+	const m = moment(value);
+	return m.isValid() ? m : null;
+}
+
+function parseExcelNumber(value: unknown): number | null {
+	if (typeof value === 'number') {
+		return Number.isFinite(value) ? value : null;
+	}
+
+	if (typeof value !== 'string') {
+		return null;
+	}
+
+	let s = value.trim();
+	if (!s) {
+		return null;
+	}
+
+	let negative = false;
+	const parenMatch = s.match(/^\((.*)\)$/);
+	if (parenMatch) {
+		negative = true;
+		s = parenMatch[1].trim();
+	}
+
+	s = s
+		.replace(/[\t\n\r]/g, '')
+		.replace(/\$/g, '')
+		.replace(/,/g, '');
+
+	s = s.trim();
+	if (!s) {
+		return null;
+	}
+
+	const num = Number(s);
+	if (!Number.isFinite(num)) {
+		return null;
+	}
+
+	return negative ? -num : num;
+}
+
+function isExcelNumericField(field: any): boolean {
+	return !!field && (
+		field.fieldType === 'Number' ||
+		field.leafValueType === 'Count' ||
+		field.leafValueType === 'Sum' ||
+		field.leafValueType === 'Average'
+	);
+}
+
+function writeExcelCell(cell: Excel.Cell, value: any, fieldMeta?: any) {
+	if (value === null || value === undefined) {
+		cell.value = '';
+		return;
+	}
+
+	if (fieldMeta?.fieldType === 'Date') {
+		const rawValue = Array.isArray(value) ? value.find(v => v !== null && v !== undefined && v !== '') : value;
+		const m = parseMoment(rawValue);
+		if (m) {
+			const timezone = process.env.TZ_CLIENT;
+			const local = timezone ? moment.tz(m.toDate(), timezone) : m.clone().local();
+			const leafFormatType = fieldMeta?.leafFormatType;
+			const excelSerial = (Date.UTC(
+				local.year(),
+				local.month(),
+				local.date(),
+				local.hour(),
+				local.minute(),
+				local.second(),
+				local.millisecond(),
+			) - Date.UTC(1899, 11, 30)) / 86400000;
+			if (leafFormatType === 'Date' || leafFormatType === 'Date_long') {
+				cell.value = Math.floor(excelSerial);
+			}
+			else if (leafFormatType === 'Time' || leafFormatType === 'DateTime' || leafFormatType === 'DateTime_long') {
+				cell.value = excelSerial;
+			}
+			else {
+				cell.value = local.toDate();
+			}
+
+			switch (leafFormatType) {
+				case 'Time':
+					cell.numFmt = 'h:mm AM/PM';
+					break;
+				case 'DateTime':
+				case 'DateTime_long':
+					cell.numFmt = 'mm/dd/yyyy h:mm AM/PM';
+					break;
+				case 'Date':
+					cell.numFmt = 'mm/dd/yyyy';
+					break;
+				case 'Date_long':
+				default:
+					cell.numFmt = 'mm/dd/yyyy';
+					break;
+			}
+
+			return;
+		}
+	}
+
+	if (Array.isArray(value)) {
+		cell.value = value.join(', ');
+		return;
+	}
+
+	if (isExcelNumericField(fieldMeta)) {
+		const parsed = parseExcelNumber(value);
+		if (parsed !== null) {
+			cell.value = parsed;
+
+			if (fieldMeta?.leafFormatType === 'Currency') {
+				cell.numFmt = '"$"#,##0.00;[Red]-"$"#,##0.00';
+			}
+			else if (fieldMeta?.leafFormatType === 'Number' || fieldMeta?.leafValueType === 'Count') {
+				cell.numFmt = '#,##0';
+			}
+
+			return;
+		}
+	}
+
+	if (typeof value === 'string') {
+		cell.value = value.replace(/\t/g, '').replace(/\n/g, '');
+	}
+	else {
+		cell.value = value;
+	}
+}
+
+function getMaxRows(row) {
+	let keys = Object.keys(row || {});
+	let maxArray = [];
+
+	for (let i = 0; i < keys.length; i++) {
+		if (Array.isArray(row[keys[i]]) && row[keys[i]].length > maxArray.length) {
+			maxArray = row[keys[i]];
+		}
+		else if (maxArray.length === 0) {
+			maxArray = [row[keys[i]]];
+		}
+	}
+
+	return maxArray;
+}
+
+function applyClientGroupSortToData(results: any[], report: any, sorts: any[] = []) {
+	if (!Array.isArray(results) || !results.length) {
+		return;
+	}
+
+	const groupIds = (report?.groups_row || []).map(g => g.id).filter(Boolean);
+
+	if (!groupIds.length) {
+		return;
+	}
+
+	const groupOrderById = {};
+	const leafSorts = [];
+
+	(sorts || []).forEach(s => {
+		if (!s?.field) {
+			return;
+		}
+
+		if (groupIds.includes(s.field)) {
+			groupOrderById[s.field] = s.order || 'asc';
+		}
+		else {
+			const leafId = resolveFieldRefToLeafId(s.field, report);
+			if (leafId) {
+				leafSorts.push({leafId, order: s.order || 'asc'});
+			}
+		}
+	});
+
+	const compareScalar = (aVal: any, bVal: any, order: string) => {
+		const dir = order === 'desc' ? -1 : 1;
+
+		const aNull = aVal === null || aVal === undefined || aVal === '';
+		const bNull = bVal === null || bVal === undefined || bVal === '';
+		if (aNull && bNull) { return 0; }
+		if (aNull) { return 1; }
+		if (bNull) { return -1; }
+
+		const aNum = typeof aVal === 'number' ? aVal : Number(aVal);
+		const bNum = typeof bVal === 'number' ? bVal : Number(bVal);
+		if (!isNaN(aNum) && !isNaN(bNum)) {
+			if (aNum === bNum) { return 0; }
+			return aNum > bNum ? dir : -dir;
+		}
+
+		const aStr = ('' + aVal).toLowerCase();
+		const bStr = ('' + bVal).toLowerCase();
+		if (aStr === bStr) { return 0; }
+		return aStr > bStr ? dir : -dir;
+	};
+
+	const selectedIds = (report?.fields_selected || []).map(f => f.id).filter(Boolean);
+
+	const sortLeafArraysInRow = (row: any) => {
+		if (!row || !leafSorts.length) {
+			return;
+		}
+
+		const arraysToReorder = selectedIds.filter(id => Array.isArray(row[id]));
+
+		if (!arraysToReorder.length) {
+			return;
+		}
+
+		let length = 0;
+		arraysToReorder.forEach(id => {
+			length = Math.max(length, row[id].length || 0);
+		});
+
+		if (length <= 1) {
+			return;
+		}
+
+		const getArrayVal = (id: string, idx: number) => {
+			const arr = row[id];
+			if (!Array.isArray(arr) || !arr.length) {
+				return null;
+			}
+			return arr[idx] !== undefined ? arr[idx] : arr[arr.length - 1];
+		};
+
+		const indices = Array.from({length}, (_, i) => i);
+		indices.sort((i, j) => {
+			for (const s of leafSorts) {
+				const aVal = Array.isArray(row[s.leafId]) ? getArrayVal(s.leafId, i) : row[s.leafId];
+				const bVal = Array.isArray(row[s.leafId]) ? getArrayVal(s.leafId, j) : row[s.leafId];
+				const cmp = compareScalar(aVal, bVal, s.order);
+				if (cmp !== 0) {
+					return cmp;
+				}
+			}
+			return 0;
+		});
+
+		arraysToReorder.forEach(id => {
+			row[id] = indices.map(idx => getArrayVal(id, idx));
+		});
+	};
+
+	const sortGroupLevel = (rows: any[], depth: number) => {
+		if (!Array.isArray(rows) || !rows.length) {
+			return;
+		}
+
+		const groupId = groupIds[depth];
+		const order = groupOrderById[groupId] || 'asc';
+		rows.sort((a, b) => compareScalar(a?._id?.[groupId], b?._id?.[groupId], order));
+
+		if (depth < groupIds.length - 1) {
+			const childId = groupIds[depth + 1];
+			rows.forEach(r => {
+				const children = r ? r[childId] : null;
+				if (Array.isArray(children)) {
+					sortGroupLevel(children, depth + 1);
+				}
+			});
+		}
+		else {
+			rows.forEach(r => sortLeafArraysInRow(r));
+		}
+	};
+
+	sortGroupLevel(results, 0);
+}
+
+const OPENAI_USAGE_BILLING_ENDPOINT = 'https://backend.resolveio.com/api/openai-usage/report';
+const AI_USAGE_SYNC_JOB_NAME = 'AI Usage Billing Sync';
+const LEGACY_AI_USAGE_SYNC_JOB_NAME = 'OpenAI Usage Billing Sync';
+const OPENAI_USAGE_DEFAULT_LOOKBACK_DAYS = 30;
+const OPENAI_USAGE_DEFAULT_BATCH_SIZE = 500;
+const OPENAI_USAGE_DEFAULT_OVERLAP_MINUTES = 10;
+const COMMUNICATION_METRICS_ENDPOINT = 'https://backend.resolveio.com/api/communication-metrics/report';
+const COMMUNICATION_METRICS_DEFAULT_LOOKBACK_DAYS = 30;
+const COMMUNICATION_METRICS_DEFAULT_BATCH_SIZE = 1000;
+const COMMUNICATION_METRICS_DEFAULT_OVERLAP_MINUTES = 10;
+
+const toNumberSetting = (value: any, fallback: number, allowZero = false): number => {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) {
+		return fallback;
+	}
+	if (allowZero && parsed === 0) {
+		return 0;
+	}
+	return parsed > 0 ? Math.floor(parsed) : fallback;
+};
+
+const normalizeString = (value: any): string => {
+	if (typeof value !== 'string') {
+		return '';
+	}
+	return value.trim();
+};
+
+const normalizeIdentifier = (value: any): string => {
+	if (value === undefined || value === null) {
+		return '';
+	}
+	return String(value).trim();
+};
+
+const normalizeDate = (value: any): Date | null => {
+	if (!value) {
+		return null;
+	}
+	const date = value instanceof Date ? value : new Date(value);
+	if (Number.isNaN(date.getTime())) {
+		return null;
+	}
+	return date;
+};
+
+const resolveOpenAIUsageSyncConfig = () => {
+	const config = ResolveIOServer.getServerConfig?.() || {};
+	const endpoint = normalizeString(
+		config['OPENAI_USAGE_BILLING_URL']
+		|| config['OPENAI_USAGE_REPORT_URL']
+		|| process.env.OPENAI_USAGE_BILLING_URL
+		|| process.env.OPENAI_USAGE_REPORT_URL
+	) || OPENAI_USAGE_BILLING_ENDPOINT;
+	const apiKey = normalizeString(
+		config['OPENAI_USAGE_INGEST_KEY']
+		|| config['OPENAI_USAGE_API_KEY']
+		|| process.env.OPENAI_USAGE_INGEST_KEY
+		|| process.env.OPENAI_USAGE_API_KEY
+		|| process.env.OPENAI_USAGE_REPORT_KEY
+	);
+	const batchSize = toNumberSetting(
+		config['OPENAI_USAGE_SYNC_BATCH_SIZE'] || process.env.OPENAI_USAGE_SYNC_BATCH_SIZE,
+		OPENAI_USAGE_DEFAULT_BATCH_SIZE
+	);
+	const lookbackDays = toNumberSetting(
+		config['OPENAI_USAGE_SYNC_LOOKBACK_DAYS'] || process.env.OPENAI_USAGE_SYNC_LOOKBACK_DAYS,
+		OPENAI_USAGE_DEFAULT_LOOKBACK_DAYS
+	);
+	const overlapMinutes = toNumberSetting(
+		config['OPENAI_USAGE_SYNC_OVERLAP_MINUTES'] || process.env.OPENAI_USAGE_SYNC_OVERLAP_MINUTES,
+		OPENAI_USAGE_DEFAULT_OVERLAP_MINUTES,
+		true
+	);
+	const enabledRaw = config['OPENAI_USAGE_SYNC_ENABLED'] ?? process.env.OPENAI_USAGE_SYNC_ENABLED;
+	const enabled = typeof enabledRaw === 'string'
+		? enabledRaw.trim().toLowerCase() !== 'false' && enabledRaw.trim() !== '0'
+		: enabledRaw !== false;
+
+	return { config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled };
+};
+
+const buildOpenAIUsageQuery = (cursorAt: Date, cursorId: string) => {
+	const base: any = {
+		billable: { $ne: false }
+	};
+
+	if (!cursorId) {
+		base.timestamp = { $gte: cursorAt };
+		return base;
+	}
+
+	base.$or = [
+		{ timestamp: { $gt: cursorAt } },
+		{ timestamp: cursorAt, _id: { $gt: cursorId } }
+	];
+	return base;
+};
+
+const normalizeUsagePayloadEntry = (entry: any) => {
+	if (!entry) {
+		return null;
+	}
+	const timestamp = normalizeDate(entry.timestamp);
+	const idClient = normalizeIdentifier(entry.id_client);
+	if (!timestamp || !idClient) {
+		return null;
+	}
+	const id = normalizeIdentifier(entry._id) || normalizeIdentifier(entry.id) || '';
+
+	return {
+		_id: id || undefined,
+		id_client: idClient,
+		timestamp: timestamp,
+		model: normalizeString(entry.model) || 'unknown',
+		input_tokens: Number(entry.input_tokens || 0),
+		output_tokens: Number(entry.output_tokens || 0),
+		total_tokens: Number(entry.total_tokens || 0),
+		cost_estimate: Number(entry.cost_estimate || 0),
+		billable: entry.billable !== false,
+		category: normalizeString(entry.category),
+		id_request: normalizeIdentifier(entry.id_request),
+		id_conversation: normalizeIdentifier(entry.id_conversation)
+	};
+};
+
+const resolveCommunicationMetricsSyncConfig = () => {
+	const config = ResolveIOServer.getServerConfig?.() || {};
+	const endpoint = normalizeString(
+		config['COMMUNICATION_METRICS_REPORT_URL']
+		|| config['COMMUNICATION_METRICS_BILLING_URL']
+		|| process.env.COMMUNICATION_METRICS_REPORT_URL
+		|| process.env.COMMUNICATION_METRICS_BILLING_URL
+	) || COMMUNICATION_METRICS_ENDPOINT;
+	const apiKey = normalizeString(
+		config['COMMUNICATION_METRICS_INGEST_KEY']
+		|| config['COMMUNICATION_METRICS_API_KEY']
+		|| process.env.COMMUNICATION_METRICS_INGEST_KEY
+		|| process.env.COMMUNICATION_METRICS_API_KEY
+		|| config['OPENAI_USAGE_INGEST_KEY']
+		|| config['OPENAI_USAGE_API_KEY']
+		|| process.env.OPENAI_USAGE_INGEST_KEY
+		|| process.env.OPENAI_USAGE_API_KEY
+		|| process.env.OPENAI_USAGE_REPORT_KEY
+	);
+	const batchSize = toNumberSetting(
+		config['COMMUNICATION_METRICS_SYNC_BATCH_SIZE'] || process.env.COMMUNICATION_METRICS_SYNC_BATCH_SIZE,
+		COMMUNICATION_METRICS_DEFAULT_BATCH_SIZE
+	);
+	const lookbackDays = toNumberSetting(
+		config['COMMUNICATION_METRICS_SYNC_LOOKBACK_DAYS'] || process.env.COMMUNICATION_METRICS_SYNC_LOOKBACK_DAYS,
+		COMMUNICATION_METRICS_DEFAULT_LOOKBACK_DAYS
+	);
+	const overlapMinutes = toNumberSetting(
+		config['COMMUNICATION_METRICS_SYNC_OVERLAP_MINUTES'] || process.env.COMMUNICATION_METRICS_SYNC_OVERLAP_MINUTES,
+		COMMUNICATION_METRICS_DEFAULT_OVERLAP_MINUTES,
+		true
+	);
+	const enabledRaw = config['COMMUNICATION_METRICS_SYNC_ENABLED'] ?? process.env.COMMUNICATION_METRICS_SYNC_ENABLED;
+	const enabled = typeof enabledRaw === 'string'
+		? enabledRaw.trim().toLowerCase() !== 'false' && enabledRaw.trim() !== '0'
+		: enabledRaw !== false;
+
+	return { config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled };
+};
+
+const buildCommunicationMetricsQuery = (cursorAt: Date, cursorId: string) => {
+	if (!cursorId) {
+		return { date: { $gte: cursorAt } };
+	}
+	return {
+		$or: [
+			{ date: { $gt: cursorAt } },
+			{ date: cursorAt, _id: { $gt: cursorId } }
+		]
+	};
+};
+
+const normalizeCommunicationMetricEntry = (entry: any) => {
+	if (!entry) {
+		return null;
+	}
+	const date = normalizeDate(entry.date || entry.timestamp);
+	const type = normalizeString(entry.type);
+	if (!date || !type) {
+		return null;
+	}
+	const value = Number(entry.value ?? entry.count ?? 0);
+	if (!Number.isFinite(value) || !value) {
+		return null;
+	}
+	const id = normalizeIdentifier(entry._id) || normalizeIdentifier(entry.id) || '';
+	const unit = normalizeString(entry.unit);
+	const metadata = entry.metadata && typeof entry.metadata === 'object' ? entry.metadata : undefined;
+
+	return {
+		_id: id || undefined,
+		date,
+		type,
+		value,
+		unit: unit || undefined,
+		metadata
+	};
+};
+
+export function loadCronJobMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		cronEmailMergedDocsCleanUp: {
+			function: async function() {
+				let files = await Files.find({$and: [{type: 'Email Merged Docs'}, {createdAt: {$lte: moment().subtract(1, 'day').toDate()}}]});
+				
+				if (files.length) {
+					await this.callMethod('deleteFiles', files.map(file => file.key));
+					await Files.deleteMany({_id: {$in: files.map(a => a._id)}});
+				}
+
+				return true;
+			}
+		},
+		stuckCronJob: {
+			function: async function() {
+				let fiveMin = moment().subtract(5, 'minutes').toDate();
+				let cronJobs = await CronJobs.find({running: true, updatedAt: {$lte: fiveMin}});
+
+				if (cronJobs.length) {
+					await CronJobs.updateMany({_id: {$in: cronJobs.map(a => a._id)}}, {$set: {running: false}});
+				}
+
+				return true;
+			}
+		},
+		cronOpenAIUsageBillingSync: {
+			check: new SimpleSchema({
+				data: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function() {
+				const { config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled } = resolveOpenAIUsageSyncConfig();
+				if (!enabled) {
+					return true;
+				}
+
+				const rootUrl = normalizeString(config['ROOT_URL']);
+				if (rootUrl === 'https://resolveio.com' || rootUrl === 'http://localhost:4200') {
+					return true;
+				}
+
+					if (!endpoint || !apiKey) {
+						console.warn('[AI Usage Sync] Missing endpoint or API key.');
+						return false;
+					}
+
+					const jobDoc = await CronJobs.findOne({
+						name: {
+							$in: [AI_USAGE_SYNC_JOB_NAME, LEGACY_AI_USAGE_SYNC_JOB_NAME]
+						}
+					});
+					const runData = (jobDoc as any)?.method_run_data as any;
+					const lastSyncedAt = normalizeDate(runData?.last_synced_at);
+					const lastSyncedId = normalizeString(runData?.last_synced_id);
+				const lookbackMs = lookbackDays * 24 * 60 * 60 * 1000;
+				let cursorAt = lastSyncedAt || new Date(Date.now() - lookbackMs);
+
+				if (lastSyncedAt && overlapMinutes > 0) {
+					cursorAt = new Date(cursorAt.getTime() - overlapMinutes * 60 * 1000);
+				}
+
+				let cursorId = lastSyncedId;
+				let totalSent = 0;
+				let cursorMoved = false;
+				const source = {
+					clientSlug: ResolveIOServer.getClientName?.(),
+					clientName: normalizeString(config['CLIENT_NAME']),
+					rootUrl: rootUrl,
+					reportedAt: new Date(),
+					appVersion: process.env.APP_VERSION
+				};
+
+				for (let i = 0; i < 1000; i++) {
+					const query = buildOpenAIUsageQuery(cursorAt, cursorId);
+					const entries = await OpenAIUsageLedger.find(query, {
+						sort: { timestamp: 1, _id: 1 },
+						limit: batchSize
+					});
+
+					if (!entries.length) {
+						break;
+					}
+
+					const payloadEntries = entries
+						.map(entry => normalizeUsagePayloadEntry(entry))
+						.filter(Boolean);
+
+					if (payloadEntries.length) {
+						await axios.post(endpoint, { entries: payloadEntries, source }, {
+							headers: {
+								'Content-Type': 'application/json',
+								'X-ResolveIO-OpenAI-Usage-Key': apiKey,
+								'X-OpenAI-Usage-Key': apiKey,
+								'X-API-Key': apiKey
+							},
+							timeout: 20000
+						});
+						totalSent += payloadEntries.length;
+					}
+
+					const lastEntry = entries[entries.length - 1];
+					if (lastEntry) {
+						cursorAt = normalizeDate(lastEntry.timestamp) || cursorAt;
+						cursorId = normalizeString(lastEntry._id) || cursorId;
+						cursorMoved = true;
+					}
+
+					if (entries.length < batchSize) {
+						break;
+					}
+				}
+
+					if (cursorMoved) {
+						const jobSelector = (jobDoc as any)?._id
+							? { _id: (jobDoc as any)._id }
+							: { name: AI_USAGE_SYNC_JOB_NAME };
+						await CronJobs.updateOne(
+							jobSelector,
+							{
+								$set: {
+									name: AI_USAGE_SYNC_JOB_NAME,
+									'method_run_data.last_synced_at': cursorAt,
+									'method_run_data.last_synced_id': cursorId,
+									'method_run_data.last_sent_at': new Date(),
+								'method_run_data.last_sent_count': totalSent
+							}
+						}
+					);
+				}
+
+				return true;
+			}
+		},
+		cronCommunicationMetricsSync: {
+			check: new SimpleSchema({
+				data: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function() {
+				const { config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled } = resolveCommunicationMetricsSyncConfig();
+				if (!enabled) {
+					return true;
+				}
+
+				const rootUrl = normalizeString(config['ROOT_URL']);
+				if (rootUrl === 'https://resolveio.com' || rootUrl === 'http://localhost:4200') {
+					return true;
+				}
+
+				if (!endpoint || !apiKey) {
+					console.warn('[Communication Metrics Sync] Missing endpoint or API key.');
+					return false;
+				}
+
+				const jobDoc = await CronJobs.findOne({ name: 'Communication Metrics Sync' });
+				const runData = (jobDoc as any)?.method_run_data as any;
+				const lastSyncedAt = normalizeDate(runData?.last_synced_at);
+				const lastSyncedId = normalizeString(runData?.last_synced_id);
+				const lookbackMs = lookbackDays * 24 * 60 * 60 * 1000;
+				let cursorAt = lastSyncedAt || new Date(Date.now() - lookbackMs);
+
+				if (lastSyncedAt && overlapMinutes > 0) {
+					cursorAt = new Date(cursorAt.getTime() - overlapMinutes * 60 * 1000);
+				}
+
+				let cursorId = lastSyncedId;
+				let totalSent = 0;
+				let cursorMoved = false;
+				const source = {
+					clientSlug: ResolveIOServer.getClientName?.(),
+					clientName: normalizeString(config['CLIENT_NAME']),
+					rootUrl: rootUrl,
+					reportedAt: new Date(),
+					appVersion: process.env.APP_VERSION
+				};
+
+				for (let i = 0; i < 1000; i++) {
+					const query = buildCommunicationMetricsQuery(cursorAt, cursorId);
+					const entries = await CommunicationMetrics.find(query, {
+						sort: { date: 1, _id: 1 },
+						limit: batchSize
+					});
+
+					if (!entries.length) {
+						break;
+					}
+
+					const payloadEntries = entries
+						.map(entry => normalizeCommunicationMetricEntry(entry))
+						.filter(Boolean);
+
+					if (payloadEntries.length) {
+						await axios.post(endpoint, { entries: payloadEntries, source }, {
+							headers: {
+								'Content-Type': 'application/json',
+								'X-ResolveIO-Communication-Metrics-Key': apiKey,
+								'X-ResolveIO-OpenAI-Usage-Key': apiKey,
+								'X-OpenAI-Usage-Key': apiKey,
+								'X-API-Key': apiKey
+							},
+							timeout: 20000
+						});
+						totalSent += payloadEntries.length;
+					}
+
+					const lastEntry = entries[entries.length - 1];
+					if (lastEntry) {
+						cursorAt = normalizeDate(lastEntry.date) || cursorAt;
+						cursorId = normalizeString((lastEntry as any)._id) || cursorId;
+						cursorMoved = true;
+					}
+
+					if (entries.length < batchSize) {
+						break;
+					}
+				}
+
+				if (cursorMoved) {
+					await CronJobs.updateOne(
+						{ name: 'Communication Metrics Sync' },
+						{
+							$set: {
+								'method_run_data.last_synced_at': cursorAt,
+								'method_run_data.last_synced_id': cursorId,
+								'method_run_data.last_sent_at': new Date(),
+								'method_run_data.last_sent_count': totalSent
+							}
+						}
+					);
+				}
+
+				return true;
+			}
+		},
+		reportbuilderCronJob: {
+			check: new SimpleSchema({
+				data: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(data: Object) {
+				if (data && data['active'] === false) {
+					return true;
+				}
+
+				let report = await ReportBuilderReports.findById(data['id_report']);
+				
+				try {
+					const layoutColumns = getLayoutColumnsFromReport(report);
+					const selectedFields = syncSelectedFieldsFromLayout(report, layoutColumns);
+					report.fields_selected = selectedFields;
+					report.fields_layout = layoutColumns;
+
+					(report.fields_selected || []).forEach((field: any, index: number) => {
+						if (!field?.id) {
+							field.id = `f_${index}`;
+						}
+					});
+
+					(report.fields_custom || []).forEach(custom => {
+						if (!custom) {
+							return;
+						}
+
+						if (!custom.selFieldId && custom.id) {
+							const match = (report.fields_selected || []).find(field => field.fieldPath === custom.id);
+							if (match?.id) {
+								custom.selFieldId = match.id;
+							}
+						}
+					});
+
+					report.fields_selected.forEach((field: any) => {
+						if (!field?.fieldPath) {
+							return;
+						}
+
+						let dotPath = field.fieldPath.replace(/\.\$/g, '');
+						let fieldData = dotPath.split('.');
+						field.fieldPathObj = null;
+						for (let i = fieldData.length - 1; i >= 0; i--) {
+							if (!field.fieldPathObj) {
+								field.fieldPathObj = {[fieldData[i]]: 1};
+							}
+							else {
+								field.fieldPathObj = {[fieldData[i]]: field.fieldPathObj};
+							}
+						}
+					});
+	
+					if ((report.fields_selected && report.fields_selected.length) || (report.groups_row && report.groups_row.length)) {
+						let fieldsObj = {};
+						const selectedFieldsForQuery = (report.fields_selected || []).filter(field => !((field?.fieldPath || '').startsWith('c_')));
+
+						report.fields_sort = report.fields_sort || [];
+
+						selectedFieldsForQuery.forEach((field: any) => {
+							if (field.collection_name === report.collection_root && field.fieldPathObj) {
+								fieldsObj = mergeDeep(fieldsObj, field.fieldPathObj);
+							}
+						});
+
+						const groupIds = (report.groups_row || []).map(g => g.id).filter(Boolean);
+						const userSorts = (report.fields_sort || []).filter(s => !!s.field);
+						const userSortByField = {};
+						userSorts.forEach(s => {
+							userSortByField[s.field] = s;
+						});
+
+						const groupSorts = groupIds.map(id => userSortByField[id] || {field: id, order: 'asc'});
+						const nonGroupSorts = userSorts.filter(s => !groupIds.includes(s.field));
+						const effectiveSorts = groupIds.length ? [...groupSorts, ...nonGroupSorts] : userSorts;
+
+						let sortObj = null;
+						if (effectiveSorts.length) {
+							sortObj = {};
+							effectiveSorts.forEach(sortField => {
+								let targetField = sortField.field;
+
+								if (!targetField) {
+									return;
+								}
+
+								if (targetField.startsWith('layout_col_')) {
+									const resolved = resolveFieldRefToLeafId(targetField, report);
+									targetField = resolved || targetField;
+								}
+
+								if (targetField.startsWith('gr_')) {
+									sortObj['_id.' + targetField] = (sortField.order === 'asc' ? 1 : -1);
+								}
+								else {
+									sortObj[targetField] = (sortField.order === 'asc' ? 1 : -1);
+								}
+							});
+						}
+
+						const totalsForQuery = (report.fields_total || []).map(total => {
+							const mappedFields = (total.fields || [])
+								.map(ref => {
+									if (!ref) {
+										return null;
+									}
+
+									if (ref.startsWith('layout_col_')) {
+										return resolveFieldRefToLeafId(ref, report);
+									}
+
+									return ref;
+								})
+								.filter(f => !!f);
+
+							return {...total, fields: mappedFields};
+						}).filter(total => (total.fields || []).length);
+						
+						report.fields_total = totalsForQuery;
+
+						let rootOptions: PaginationOptions = {
+							limit: 0,
+							skip: 0,
+							fields: fieldsObj,
+							sort: sortObj
+						};
+
+						let filters = [];
+						let filterArrayFields = [];
+						let filterArrays = [];
+
+						selectedFieldsForQuery
+							.filter(f => (f.fieldPath || '').includes('.$.'))
+							.forEach(sel => {
+								if (!filterArrayFields.some(f => f?.fieldPath === sel.fieldPath)) {
+									filterArrayFields.push(sel);
+								}
+							});
+
+						(report.fields_filter || []).forEach(filterAnd => {
+							let ors = [];
+							let hasArrayTarget = false;
+
+							(filterAnd.ors || []).forEach((filter: any) => {
+								const targets = getFilterTargets(filter.field, report);
+
+								if (!targets.length) {
+									return;
+								}
+
+								targets.forEach(path => {
+									const isArrayTarget = path.includes('.$.');
+									const normalizedPath = path.replace(/\.\$/g, '');
+									const expr = buildFilterExpression(filter, normalizedPath);
+
+									if (expr) {
+										ors.push(expr);
+									}
+
+									if (isArrayTarget) {
+										hasArrayTarget = true;
+										const leaf = selectedFieldsForQuery.find(a => a.fieldPath === path);
+										if (leaf && !filterArrayFields.some(f => f?.fieldPath === leaf.fieldPath)) {
+											filterArrayFields.push(leaf);
+										}
+									}
+								});
+							});
+
+							if (ors.length) {
+								const filterObj = {$or: ors};
+								if (hasArrayTarget) {
+									filterArrays.push(filterObj);
+								}
+								else {
+									filters.push(filterObj);
+								}
+							}
+						});
+
+						const res = await this.callMethod('reportBuilderGetResults', report.type, report.collection_root, rootOptions, filters, filterArrays, filterArrayFields, selectedFieldsForQuery, report.fields_custom, report.groups_row, totalsForQuery, report.fields_link, report.id_date_field || null, report.date_interval || null,  report.group_type);
+
+						if (res && res[0]) {
+							let results = res[0].results;
+							let reportTotals = res[0].totals;
+
+							if (report.type === 'Group') {
+								applyClientGroupSortToData(results, report, effectiveSorts);
+							}
+
+							const customFields = (report.fields_custom || []).map(cust => ({
+								...cust,
+								id: cust.selFieldId,
+								fieldType: 'Number',
+								leafValueType: cust.leafValueType || 'Value',
+								leafFormatType: 'Number',
+								columnName: cust.columnName || cust.id,
+								show: true
+							}));
+
+							const exportFields = report.fields_selected.filter(a => a.show).concat((<any>customFields));
+					
+							if (report.type === 'List') {
+								exportFields.forEach(field => {
+									if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Number') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined ).forEach(result => {
+											result[field.id] = result[field.id].toLocaleString();
+										});
+									}
+									else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'String') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = result[field.id].toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+										});
+									}
+									else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Currency') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = round(result[field.id], 2).toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+										});
+									}
+									else if (field.fieldType === 'Boolean' && (!field.leafFormatType || field.leafFormatType === 'Boolean')) {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = result[field.id] === true ? 'True' : 'False';
+										});
+									}
+									else if (field.fieldType === 'Boolean' && field.leafFormatType === 'String') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = result[field.id] === true ? 'Yes' : 'No';
+										});
+									}
+									else if (field.fieldType === 'Boolean' && field.leafFormatType === 'Boolean_Number') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = result[field.id] === true ? 1 : 0;
+										});
+									}
+									else if (field.fieldType === 'Date' && (field.leafFormatType === 'Date')) {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = moment(result[field.id]).format('L');
+										});
+									}
+									else if (field.fieldType === 'Date' && field.leafFormatType === 'Time') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = moment(result[field.id]).format('LT');
+										});
+									}
+									else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = moment(result[field.id]).format('MM/DD/YYYY h:mm A');
+										});
+									}
+									else if (field.fieldType === 'Date' && field.leafFormatType === 'Date_long') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = moment(result[field.id]).format('LL');
+										});
+									}
+									else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime_long') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = moment(result[field.id]).format('LLL');
+										});
+									}
+									else if (field.fieldType === 'Date' && field.leafFormatType === 'Timestamp') {
+										results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+											result[field.id] = moment(result[field.id]).toDate().getTime();
+										});
+									}
+								});
+
+								let wb = new Excel.Workbook();
+								let ws = wb.addWorksheet('RB_1', {views: [{showGridLines: true}]});
+								wb.properties.date1904 = false;
+								wb.calcProperties.fullCalcOnLoad = true;
+
+								let currentRow = 1;
+								let row = ws.getRow(currentRow);
+
+								row.getCell(2).font = {
+									name: 'Arial',
+									bold: true,
+									size: 14
+								};
+								row.getCell(4).font = {
+									name: 'Arial',
+									size: 14
+								};
+								row.getCell(2).value = 'Report Name:';
+								row.getCell(4).value = report.report_name;
+
+								currentRow += 1;
+								row = ws.getRow(currentRow);
+
+								row.getCell(2).font = {
+									name: 'Arial',
+									bold: true,
+									size: 14
+								};
+								row.getCell(4).font = {
+									name: 'Arial',
+									size: 14
+								};
+								row.getCell(2).value = 'Run Date:';
+								row.getCell(4).value = moment().format('LLL');
+
+								currentRow += 2;
+								row = ws.getRow(currentRow);
+
+								const useLayout = (layoutColumns && layoutColumns.length > 0);
+								const headers: string[] = [];
+
+								report.groups_row.forEach(group => {
+									headers.push(group.columnName);
+								});
+
+								if (useLayout) {
+									layoutColumns.forEach((col, idx) => {
+										headers.push(col.header || `Column ${idx + 1}`);
+									});
+								}
+								else {
+									exportFields.forEach(field => {
+										headers.push(field.columnName);
+									});
+								}
+
+								headers.forEach((header, headerIdx) => {
+									row.getCell(headerIdx + 1).value = header;
+								});
+
+								currentRow += 1;
+								row = ws.getRow(currentRow);
+
+								const exportResults = deepCopy(results || []);
+
+								exportResults.forEach(result => {
+									let currentCol = 1;
+
+									report.groups_row.forEach(group => {
+										writeExcelCell(row.getCell(currentCol), result?._id?.[group.id] ?? '', group.treeItem);
+										currentCol += 1;
+									});
+
+									if (useLayout) {
+										const layoutRow = materializeLayoutRow(report, layoutColumns, report.fields_selected, result);
+										layoutColumns.forEach((col, colIdx) => {
+											const cellValue = getLayoutCellExportValue(report, layoutRow, colIdx);
+											const primaryFieldMeta = getPrimaryFieldForLayoutColumn(col, report.fields_selected);
+											writeExcelCell(row.getCell(currentCol), cellValue === undefined ? '' : cellValue, primaryFieldMeta);
+											currentCol += 1;
+										});
+									}
+									else {
+										exportFields.forEach(field => {
+											writeExcelCell(row.getCell(currentCol), result[field.id] ?? '', field);
+											currentCol += 1;
+										});
+									}
+
+									currentRow += 1;
+									row = ws.getRow(currentRow);
+								});
+
+								try {
+									let buffer = await wb.xlsx.writeBuffer();
+									for (let email of data['emails']) {
+										await this.sendEmail(email,
+											this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name,
+											'',
+											`
+											<b>` + this.serverConfig['CLIENT_NAME'] + ` Automated Report</b><br>
+											<b>Report Name: </b>` + report.report_name + `<br>
+											<b>Prepared By: </b>` + data['user'] + `<br><br>
+											Attached are the results of this automated report.<br><br>
+											ResolveIO<br><br>`,
+											[
+												{
+													filename: report.report_name + '-' + moment().format('MM-DD-YYYY-hh-mm-A') + '.xlsx',
+													content: buffer
+												}
+											],
+											this.serverConfig['MAIL_FROM_REPORTS'],
+											''
+										);
+									}
+								}
+								catch (err) {
+									console.log('Error writing excel export', err);
+								}
+							}
+							else if (report.type === 'Group') {
+								exportFields.forEach(field => {
+									results.forEach(result => {
+										modifyDataTypeField(report, result, field, 1);
+									});
+								});
+
+								let wb = new Excel.Workbook();
+								let ws = wb.addWorksheet('RB_1', {views: [{showGridLines: false}]});
+								wb.properties.date1904 = false;
+								wb.calcProperties.fullCalcOnLoad = true;
+
+								let currentRow = 1;
+								let row = ws.getRow(currentRow);
+
+								row.getCell(2).font = {
+									name: 'Arial',
+									bold: true,
+									size: 14
+								};
+								row.getCell(4).font = {
+									name: 'Arial',
+									size: 14
+								};
+								row.getCell(2).value = 'Report Name:';
+								row.getCell(4).value = report.report_name;
+
+								currentRow += 1;
+								row = ws.getRow(currentRow);
+
+								row.getCell(2).font = {
+									name: 'Arial',
+									bold: true,
+									size: 14
+								};
+								row.getCell(4).font = {
+									name: 'Arial',
+									size: 14
+								};
+								row.getCell(2).value = 'Run Date:';
+								row.getCell(4).value = moment().format('LLL');
+
+								currentRow += 2;
+
+								let copy = deepCopy(results);
+								let widths = [];
+								copy.forEach(res => {
+									currentRow = tabGroupExcelRecursive(report, ws, currentRow, 1, res, exportFields);
+									tabGroupExcelWidthRecursive(report, 1, res, widths, exportFields);
+								});
+
+								for (let i = 1; i < ws.columns.length; i++) {
+									ws.columns[i].width = widths[i - 1];
+								}
+
+								let now = new Date();
+
+								try {
+									let buffer = await wb.xlsx.writeBuffer();
+									for (let email of data['emails']) {
+										await this.sendEmail(email,
+											this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name,
+											'',
+											`
+											<b>` + this.serverConfig['CLIENT_NAME'] + ` Automated Report</b><br>
+											<b>Report Name: </b>` + report.report_name + `<br>
+											<b>Prepared By: </b>` + data['user'] + `<br><br>
+											Attached are the results of this automated report.<br><br>
+											Have a great day!<br><br>
+											ResolveIO<br><br>`,
+											[
+												{
+													filename: 'Group_Report_' + report.report_name + '_' + now.getFullYear() + '_' + (now.getMonth() + 1) + '_' + now.getDate() + '.xlsx',
+													content:  buffer
+												}
+											],
+											this.serverConfig['MAIL_FROM_REPORTS'],
+											''
+										);
+									}
+								}
+								catch (err) {
+									console.log('Error writing excel export', err)
+								};
+							}
+							else if (report.type === 'Dated') {
+								let datedUniqueDates = [];
+								let datedUniqueGroups = [];
+								let datedData = [];
+								let reportTotalGroups = [];
+								let reportTotalDates = [];
+							
+								// Step 1: Handle quarterly dates if applicable
+								if (report.date_interval === 'Quarterly') {
+									results.forEach(dataPt => {
+										if (dataPt._id.month < 4) {
+											dataPt._id.quarter = 1;
+										}
+										else if (dataPt._id.month < 7) {
+											dataPt._id.quarter = 2;
+										}
+										else if (dataPt._id.month < 10) {
+											dataPt._id.quarter = 3;
+										}
+										else {
+											dataPt._id.quarter = 4;
+										}
+
+										delete dataPt._id.month;
+									});
+
+									// Deduplicate quarterly data
+									for (let i = results.length - 1; i >= 1; i--) {
+										let dataPt = results[i];
+										if (results.filter(a => JSON.stringify(a._id) === JSON.stringify(dataPt._id)).length > 1) {
+											let tmpData = results.find(a => JSON.stringify(a._id) === JSON.stringify(dataPt._id));
+
+											Object.keys(tmpData)
+												.filter(a => a !== '_id')
+												.forEach(key => {
+													tmpData[key] += dataPt[key];
+												});
+							
+											results.splice(i, 1); // Remove the duplicate entry
+										}
+									}
+								}
+
+								// Step 2: Prepare unique groups
+								let tmpResults = deepCopy(results);
+								tmpResults.forEach(result => {
+									delete result._id.day;
+									delete result._id.week;
+									delete result._id.month;
+									delete result._id.quarter;
+									delete result._id.year;
+
+									let tmpGroup = {};
+									Object.keys(result._id).forEach(key => {
+										tmpGroup[key] = result._id[key];
+									});
+
+									if (!datedUniqueGroups.find(a => JSON.stringify(a) === JSON.stringify(tmpGroup))) {
+										datedUniqueGroups.push(tmpGroup);
+									}
+								});
+
+								// Step 3: Prepare unique dates
+								tmpResults = deepCopy(results);
+								tmpResults.forEach(result => {
+									Object.keys(result._id)
+										.filter(a => a !== 'second' && a !== 'hour' && a !== 'minute' && a !== 'day' && a !== 'week' && a !== 'month' && a !== 'quarter' && a !== 'year')
+										.forEach(key => {
+											delete result._id[key];
+										});
+
+									let tmpDate = {};
+									Object.keys(result._id).forEach(key => {
+										tmpDate[key] = result._id[key];
+									});
+
+									if (!datedUniqueDates.find(a => JSON.stringify(a) === JSON.stringify(tmpDate))) {
+										datedUniqueDates.push(tmpDate);
+									}
+								});
+
+								// Build the date strings
+								// Ensure moment is using America/Chicago timezone for all date processing
+								datedUniqueDates.forEach(result => {
+									if (!result.year) {
+										result.dateString = 'No Date';
+									}
+									else {
+										if (report.date_interval === 'Seconds') {
+											result.date = moment.tz({
+												year: result.year,
+												month: result.month - 1,  // Use `month - 1` since months are zero-indexed in moment as well
+												day: result.day,
+												hour: result.hour,
+												minute: result.minute,
+												second: result.second
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).toDate();
+											result.dateString = moment(result.date).format('MMM DD YYYY HH:mm:ss');
+										}
+										else if (report.date_interval === 'Minutes') {
+											result.date = moment.tz({
+												year: result.year,
+												month: result.month - 1,
+												day: result.day,
+												hour: result.hour,
+												minute: result.minute
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).toDate();
+											result.dateString = moment(result.date).format('MMM DD YYYY HH:mm');
+										}
+										else if (report.date_interval === 'Hours') {
+											result.date = moment.tz({
+												year: result.year,
+												month: result.month - 1,
+												day: result.day,
+												hour: result.hour
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).toDate();
+											result.dateString = moment(result.date).format('MMM DD YYYY HH');
+										}
+										else if (report.date_interval === 'Daily') {
+											result.date = moment.tz({
+												year: result.year,
+												month: result.month - 1,
+												day: result.day
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).toDate();
+											result.dateString = moment(result.date).format('MMM DD YYYY');
+										}
+										else if (report.date_interval === 'Weekly') {
+											result.date = moment.tz({
+												year: result.year,
+												week: result.week
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).day('Monday').toDate();
+											result.dateLast = moment.tz({
+												year: result.year,
+												week: result.week
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).day('Sunday').toDate();
+											result.dateString = 'Week #' + result.week + ' ' + result.year + ' (' + moment(result.date).format('MM/DD/YY') + ' - ' + moment(result.dateLast).format('MM/DD/YY') + ')';
+										}
+										else if (report.date_interval === 'Monthly') {
+											result.date = moment.tz({
+												year: result.year,
+												month: result.month - 1,  // Months are zero-indexed in moment
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).toDate();
+											result.dateString = moment(result.date).format('MMM YYYY');
+										}
+										else if (report.date_interval === 'Quarterly') {
+											result.date = moment.tz({
+												year: result.year
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).quarter(result.quarter).toDate();;
+											result.dateString = 'Q' + result.quarter + ' ' + result.year;
+										}
+										else if (report.date_interval === 'Yearly') {
+											result.date = moment.tz({
+												year: result.year
+											}, (process.env.TZ_CLIENT || 'America/Chicago')).toDate();
+											result.dateString = result.year.toString();
+										}
+									}
+								});
+							
+								datedUniqueDates = datedUniqueDates.filter(a => !a.date)
+									.concat(datedUniqueDates.filter(a => a.date).sort((a, b) => a.date.getTime() - b.date.getTime()));
+							
+								// Step 4: Build datedData and reportTotalGroups
+								datedUniqueDates.forEach(date => {
+									let tmpData = [];
+									let tmpTotalDated = {};
+									let tmpTotalCnt = {};
+									let tmpTotalType = {};
+
+									datedUniqueGroups.forEach(group => {
+										let result = results.find(a => {
+											let match = true;
+
+											// Match the group fields
+											Object.keys(group).forEach(key => {
+												if (a._id[key] !== group[key]) {
+													match = false;
+												}
+											});
+							
+											// Match the date fields
+											Object.keys(date).filter(key => key !== 'date' && key !== 'dateLast' && key !== 'dateString').forEach(key => {
+												if (a._id[key] !== date[key]) {
+													match = false;
+												}
+											});
+							
+											return match;
+										});
+							
+										if (result) {
+											tmpData.push(result);
+							
+											Object.keys(result._id).filter(a => a).forEach(key => {
+												if (report.fields_total.filter(a => a.fields.includes(key)).length) {
+													if (!tmpTotalDated[key]) {
+														tmpTotalDated[key] = result._id[key];
+													}
+													else {
+														tmpTotalDated[key] += result._id[key];
+													}
+
+													if (!tmpTotalCnt[key]) {
+														tmpTotalCnt[key] = 1;
+													}
+													else {
+														tmpTotalCnt[key] += 1;
+													}
+
+													tmpTotalType[key] = report.fields_total.find(a => a.fields.includes(key)).type;
+												}
+											});
+							
+											Object.keys(result).filter(a => a && a !== '_id').forEach(key => {
+												if (report.fields_total.filter(a => a.fields.includes(key)).length) {
+													if (!tmpTotalDated[key]) {
+														tmpTotalDated[key] = result[key];
+													}
+													else {
+														tmpTotalDated[key] += result[key];
+													}
+
+													if (!tmpTotalCnt[key]) {
+														tmpTotalCnt[key] = 1;
+													}
+													else {
+														tmpTotalCnt[key] += 1;
+													}
+
+													tmpTotalType[key] = report.fields_total.find(a => a.fields.includes(key)).type;
+												}
+											});
+										}
+										else {
+											tmpData.push(null);
+										}
+									});
+
+									// Handle averaging for totals
+									Object.keys(tmpTotalType).forEach(totalKey => {
+										if (tmpTotalType[totalKey] === 'avg') {
+											tmpTotalDated[totalKey] = tmpTotalDated[totalKey] / tmpTotalCnt[totalKey];
+										}
+
+										tmpTotalDated[totalKey] = round(tmpTotalDated[totalKey], 2);
+									});
+
+									reportTotalDates.push(tmpTotalDated);
+									datedData.push(tmpData);
+								});
+							
+								// Calculate group-level totals
+								datedUniqueGroups.forEach(group => {
+									let tmpTotalGroup = {};
+									let filteredData = results.filter(a => {
+										let match = (!Object.keys(group).length || group._id === null) ? false : true;
+										Object.keys(group).filter(a => a !== 'date' && a !== 'dateLast' && a !== 'dateString' && a !== 'second' && a !== 'minute' && a !== 'hour' && a !== 'day' && a !== 'week' && a !== 'month' && a !== 'quarter' && a !== 'year').forEach(key => {
+											if (a._id[key] !== group[key]) {
+												match = false;
+											}
+										});
+										return match;
+									});
+							
+									report.fields_total.forEach(total => {
+										total.fields.forEach(field => {
+											if (filteredData.length) {
+												tmpTotalGroup[field] = filteredData.filter(a => a && a[field])
+													.map(a => a[field])
+													.reduce((a, b) => a + b, 0);
+							
+												if (total.type === 'avg') {
+													tmpTotalGroup[field] = round(tmpTotalGroup[field] / filteredData.length, 2);
+												}
+											}
+											else {
+												tmpTotalGroup[field] = 0;
+											}
+										});
+									});
+
+									reportTotalGroups.push(tmpTotalGroup);
+								});
+							
+								// Step 5: Proceed with Excel generation using datedData and reportTotalGroups
+								let wb = new Excel.Workbook();
+								let ws = wb.addWorksheet('Dated_Report', {views: [{showGridLines: true}]});
+								wb.properties.date1904 = false;
+								wb.calcProperties.fullCalcOnLoad = true;
+							
+								let currentRow = 1;
+								let currentCol = 1;
+								let row = ws.getRow(currentRow);
+
+								row.getCell(2).font = {
+									name: 'Arial',
+									bold: true,
+									size: 14
+								};
+								row.getCell(4).font = {
+									name: 'Arial',
+									size: 14
+								};
+								row.getCell(2).value = 'Report Name:';
+								row.getCell(4).value = report.report_name;
+								
+								currentRow += 1;
+								row = ws.getRow(currentRow);
+
+								row.getCell(2).font = {
+									name: 'Arial',
+									bold: true,
+									size: 14
+								};
+								row.getCell(4).font = {
+									name: 'Arial',
+									size: 14
+								};
+								row.getCell(2).value = 'Run Date:';
+								row.getCell(4).value = moment().format('LLL');
+							
+								currentRow += 2;
+								row = ws.getRow(currentRow);
+							
+								// Add group column headers
+								report.groups_row.forEach(group => {
+									row.getCell(currentCol).value = group.columnName;
+									currentCol++;
+								});
+							
+								// Add field headers
+								currentCol += report.fields_selected.filter(a => a.show).length;
+							
+								// Add the date interval headers
+								report.fields_selected.filter(a => a.show).forEach(() => {
+									datedUniqueDates.forEach(date => {
+										row.getCell(currentCol).value = date.dateString;
+										currentCol++;
+									});
+								});
+							
+								// Add totals headers
+								report.fields_total.forEach(total => {
+									row.getCell(currentCol).value = 'Totals - ' + toTitleCase(total.type);
+									currentCol++;
+								});
+							
+								currentCol = 1;
+								currentRow += 1;
+								row = ws.getRow(currentRow);
+							
+								// Populate data for each group and field with date intervals
+								for (let i = 0; i < datedUniqueGroups.length; i++) {
+									let group = datedUniqueGroups[i];
+							
+									for (let j = 0; j < report.fields_selected.filter(a => a.show).length; j++) {
+										let field = report.fields_selected.filter(a => a.show)[j];
+							
+										currentCol = 1;
+										row = ws.getRow(currentRow);
+							
+										// Populate group data
+										report.groups_row.forEach(groupRow => {
+											row.getCell(currentCol).value = (j === 0) ? group[groupRow.id] : '';
+											currentCol++;
+										});
+							
+										// Populate field data
+										row.getCell(currentCol).value = field.columnName;
+										currentCol++;
+							
+										// Populate date interval data for each field
+										for (let k = 0; k < datedUniqueDates.length; k++) {
+											let result = datedData[k];
+											if (result[i]) {
+												row.getCell(currentCol).value = result[i][field.id] ? result[i][field.id] : '';
+											}
+											else {
+												row.getCell(currentCol).value = '';
+											}
+											currentCol++;
+										}
+							
+										// Add totals for each field in the report
+										for (let k = 0; k < report.fields_total.length; k++) {
+											row.getCell(currentCol).value = reportTotalGroups[i][field.id] ? reportTotalGroups[i][field.id] : '';
+											currentCol++;
+										}
+							
+										currentRow++; // Move to the next row for the next field
+									}
+								}
+							
+								// Add report totals at the bottom
+								if (reportTotals) {
+									for (let i = 0; i < report.fields_total.length; i++) {
+										let total = report.fields_total[i];
+										row = ws.getRow(currentRow);
+										currentCol = 1;
+							
+										row.getCell(currentCol).value = toTitleCase(total.type) + ' Totals';
+										currentCol += report.groups_row.length; // Skip group columns
+							
+										// Skip the date columns for the totals row
+										report.fields_selected.filter(a => a.show).forEach(() => {
+											currentCol += 1;
+										});
+
+										datedUniqueDates.forEach(() => {
+											currentCol++;
+										});
+							
+										// Set totals in the correct fields
+										for (let j = 0; j < report.fields_selected.filter(a => a.show).length; j++) {
+											let field = report.fields_selected.filter(a => a.show)[j];
+											row.getCell(currentCol).value = reportTotals[total.id + '_' + field.id] || '';
+											currentCol++;
+										}
+							
+										currentRow++; // Move to the next row for the next total
+									}
+								}
+							
+								try {
+									// Save the Excel file and send it via email
+									let buffer = await wb.xlsx.writeBuffer();
+									for (let email of data['emails']) {
+										await this.sendEmail(
+											email,
+											this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name,
+											'',
+											`
+											<b>${this.serverConfig['CLIENT_NAME']} Automated Report</b><br>
+											<b>Report Name: </b>${report.report_name}<br>
+											<b>Prepared By: </b>${data['user']}<br><br>
+											Attached are the results of this automated report.<br><br>
+											ResolveIO<br><br>`,
+											[
+												{
+													filename: report.report_name + '-' + moment().format('MM-DD-YYYY-hh-mm-A') + '.xlsx',
+													content: buffer
+												}
+											],
+											this.serverConfig['MAIL_FROM_REPORTS'],
+											''
+										);
+										}
+									}
+								catch (err) {
+									console.log('Error writing excel export', err);
+								}
+
+								return true;
+							}
+						}
+					}
+				}
+				catch (err) {
+					err.message = `Error in Report Builder Cron Job - Report Builder Build Tree: ${err.message}`;
+					throw err;
+				}
+
+				return true;
+			}
+		}
+	});
+}
+
+function modifyDataTypeField(report, result, field, index) {
+	const processFieldValue = (value, field) => {
+		if (value === undefined || value === null) {
+			return '';
+		}
+
+		if (field.fieldType === 'Boolean') {
+			if (!field.leafFormatType || field.leafFormatType === 'Boolean') {
+				return value === true ? 'True' : 'False';
+			}
+			else if (field.leafFormatType === 'String') {
+				return value === true ? 'Yes' : 'No';
+			}
+			else if (field.leafFormatType === 'Boolean_Number') {
+				return value === true ? 1 : 0;
+			}
+		}
+		else if (field.fieldType === 'Number' || field.leafValueType === 'Count') {
+			if (field.leafFormatType === 'Number') {
+				return value.toLocaleString();
+			}
+			else if (field.leafFormatType === 'String') {
+				return value.toString();
+			}
+			else if (field.leafFormatType === 'Currency') {
+				return round(value, 2).toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+			}
+		}
+		else if (field.fieldType === 'Date') {
+			switch (field.leafFormatType) {
+				case 'Date':
+					return moment(value).format('L');
+				case 'Time':
+					return moment(value).format('LT');
+				case 'DateTime':
+					return moment(value).format('MM/DD/YYYY h:mm A');
+				case 'Date_long':
+					return moment(value).format('LL');
+				case 'DateTime_long':
+					return moment(value).format('LLL');
+				case 'Timestamp':
+					return moment(value).toDate().getTime();
+				default:
+					return value;
+			}
+		}
+
+		return value;
+	};
+
+	const processArrayField = (array, field) => {
+		return array.map(value => processFieldValue(value, field));
+	};
+
+	if (index < report.groups_row.length) {
+		// Handle grouped data
+		const groupKey = 'gr_' + (index + 1);
+		if (result[groupKey]) {
+			result[groupKey].forEach(subResult => {
+				modifyDataTypeField(report, subResult, field, index + 1);
+			});
+		}
+	}
+	else {
+		// Process final-level fields
+		if (Array.isArray(result[field.id])) {
+			result[field.id] = processArrayField(result[field.id], field);
+		}
+		else {
+			result[field.id] = processFieldValue(result[field.id], field);
+		}
+	}
+}
+
+function tabGroupExcelRecursive(report, ws: Excel.Worksheet, currentRow, level, result, fields) {
+	let row = ws.getRow(currentRow);
+	const fieldCount = fields.length;
+
+	if (level < report.groups_row.length) {
+		row.getCell(2).fill = {
+			fgColor: {argb: report.groups_row[level - 1].fill_color ? report.groups_row[level - 1].fill_color.replace('#', '') : 'ffffff'},
+			type: 'pattern',
+			pattern: 'solid'
+		};
+		row.getCell(2).font = {
+			color: {argb: report.groups_row[level - 1].font_color ? report.groups_row[level - 1].font_color.replace('#', '') : '000000'},
+			name: 'Arial',
+			bold: true,
+			size: 14
+		};
+		
+		const currentGroup = report.groups_row[level - 1];
+		row.getCell(2).value = currentGroup.columnName + ': ' + (result._id[currentGroup.id] || '');
+		ws.mergeCells(row.getCell(2).$col$row + ':' + row.getCell(fieldCount + 1).$col$row);
+		
+		row.getCell(2).border = {
+			top: {style:'thick'},
+			left: {style:'thick'},
+			right: {style: 'thick'}
+		};
+
+		if (report.fields_total.length) {
+			report.fields_total.forEach(total => {
+				currentRow += 1;
+				row = ws.getRow(currentRow);
+
+				fields.forEach((field, fieldIndex) => {
+					if (total.fields.includes(field.id)) {
+						row.getCell(fieldIndex + 2).value = field.columnName;
+
+						row.getCell(fieldIndex + 2).font = {
+							name: 'Arial',
+							bold: true,
+							size: 10
+						};
+					}
+
+					if (field.leafFormatType === 'Currency') {
+						row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+					}
+					else if (field.leafFormatType === 'Number') {
+						row.getCell(fieldIndex + 2).numFmt = '#,##0';
+					}
+
+					if (fieldIndex === 0) {
+						row.getCell(fieldIndex + 2).border = {
+							left: {style:'thick'}
+						};
+					}
+					else if (fieldIndex === fieldCount - 1) {
+						row.getCell(fieldIndex + 2).border = {
+							right: {style:'thick'}
+						};
+					}
+				});
+			});
+		}
+		
+		// Totals
+		report.fields_total.forEach(total => {
+			currentRow += 1;
+			row = ws.getRow(currentRow);
+
+			fields.forEach((field, fieldIndex) => {
+				if (total.fields.includes(field.id)) {
+					row.getCell(fieldIndex + 2).value = result[total.id + '_' + field.id];
+
+					row.getCell(fieldIndex + 2).font = {
+						name: 'Arial',
+						bold: true,
+						size: 10
+					};
+
+					if (field.leafFormatType === 'Currency') {
+						row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+					}
+					else if (field.leafFormatType === 'Number') {
+						row.getCell(fieldIndex + 2).numFmt = '#,##0';
+					}
+				}
+
+				if (fieldIndex === 0) {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						left: {style:'thick'},
+						bottom: {style:'thick'}
+					};
+				}
+				else if (fieldIndex === fieldCount - 1) {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						bottom: {style:'thick'},
+						right: {style:'thick'}
+					};
+				}
+				else {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						bottom: {style:'thick'}
+					};
+				}
+			});
+		});
+		
+		currentRow += 1;
+
+			const nextGroup = report.groups_row[level];
+			if (nextGroup) {
+				const nextResults = result[nextGroup.id];
+				if (Array.isArray(nextResults)) {
+					nextResults.forEach(tDataRes => {
+						currentRow = tabGroupExcelRecursive(report, ws, currentRow, level + 1, tDataRes, fields);
+					});
+				}
+			}
+	}
+	else {
+		row.getCell(2).fill = {
+			fgColor: {argb: report.groups_row[level - 1].fill_color ? report.groups_row[level - 1].fill_color.replace('#', '') : 'ffffff'},
+			type: 'pattern',
+			pattern: 'solid'
+		};
+		row.getCell(2).font = {
+			color: {argb: report.groups_row[level - 1].font_color ? report.groups_row[level - 1].font_color.replace('#', '') : '000000'},
+			name: 'Arial',
+			bold: true,
+			size: 12
+		};
+
+		const finalGroup = report.groups_row[level - 1];
+		row.getCell(2).value = finalGroup.columnName + ': ' + (result._id[finalGroup.id] || '');
+		ws.mergeCells(row.getCell(2).$col$row + ':' + row.getCell(fieldCount + 1).$col$row);
+
+		row.getCell(2).border = {
+			top: {style:'thick'},
+			left: {style:'thick'},
+			right: {style: 'thick'}
+		};
+
+		currentRow += 1;
+		row = ws.getRow(currentRow);
+		// Headers
+		fields.forEach((field, fieldIndex) => {
+			row.getCell(fieldIndex + 2).value = field.columnName;
+			row.getCell(fieldIndex + 2).font = {
+				name: 'Arial',
+				bold: true,
+				size: 10
+			};
+
+			if (field.leafFormatType === 'Currency') {
+				row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+			}
+			else if (field.leafFormatType === 'Number') {
+				row.getCell(fieldIndex + 2).numFmt = '#,##0';
+			}
+
+			if (fieldIndex === 0) {
+				row.getCell(fieldIndex + 2).border = {
+					left: {style:'thick'}
+				};
+			}
+			else if (fieldIndex === fieldCount - 1) {
+				row.getCell(fieldIndex + 2).border = {
+					right: {style:'thick'}
+				};
+			}
+		});
+
+		// Data
+		getMaxRows(result).forEach((res, resIndex) => {
+			currentRow += 1;
+			row = ws.getRow(currentRow);
+
+			fields.forEach((field, fieldIndex) => {
+				let value = null;
+
+				if (Array.isArray(result[field.id])) {
+					value = result[field.id][resIndex] !== undefined ? result[field.id][resIndex] : result[field.id][result[field.id].length - 1];
+				}
+				else {
+					value = result[field.id];
+				}
+
+				if (field.fieldType === 'Number' && typeof(value) === 'string' && value) {
+					row.getCell(fieldIndex + 2).value = parseFloat(value.replace(new RegExp(/\,/g), '').replace(new RegExp(/\$/g), ''));
+				}
+				else {
+					row.getCell(fieldIndex + 2).value = value;
+				}
+
+				if (field.leafFormatType === 'Currency') {
+					row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+				}
+				else if (field.leafFormatType === 'Number') {
+					row.getCell(fieldIndex + 2).numFmt = '#,##0';
+				}
+
+				row.getCell(fieldIndex + 2).font = {
+					name: 'Arial',
+					size: 10
+				};
+
+				if (fieldIndex === 0) {
+					row.getCell(fieldIndex + 2).border = {
+						left: {style:'thick'}
+					};
+				}
+				else if (fieldIndex === fieldCount - 1) {
+					row.getCell(fieldIndex + 2).border = {
+						right: {style:'thick'}
+					};
+				}
+			});
+		});
+		
+		// Totals
+		report.fields_total.forEach(total => {
+			currentRow += 1;
+			row = ws.getRow(currentRow);
+
+			fields.forEach((field, fieldIndex) => {
+				if (total.fields.includes(field.id)) {
+					row.getCell(fieldIndex + 2).value = result[total.id + '_' + field.id];
+
+					row.getCell(fieldIndex + 2).font = {
+						name: 'Arial',
+						bold: true,
+						size: 10
+					};
+
+					if (field.leafFormatType === 'Currency') {
+						row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+					}
+					else if (field.leafFormatType === 'Number') {
+						row.getCell(fieldIndex + 2).numFmt = '#,##0';
+					}
+				}
+
+				if (fieldIndex === 0) {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						left: {style:'thick'},
+						bottom: {style:'thick'}
+					};
+				}
+				else if (fieldIndex === fieldCount - 1) {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						bottom: {style:'thick'},
+						right: {style:'thick'}
+					};
+				}
+				else {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						bottom: {style:'thick'}
+					};
+				}
+			});
+		});
+	}
+
+	return currentRow + 1;
+}
+
+function tabGroupExcelWidthRecursive(report, level, result, cols, fields) {
+	if (level < report.groups_row.length) {
+			const nextGroup = report.groups_row[level];
+			if (nextGroup) {
+				const nextResults = result[nextGroup.id];
+				if (Array.isArray(nextResults)) {
+					nextResults.forEach(tDataRes => {
+						cols = tabGroupExcelWidthRecursive(report, level + 1, tDataRes, cols, fields);
+					});
+				}
+			}
+	}
+	else {
+		fields.forEach((field, fieldIndex) => {
+			if (Array.isArray(result[field.id])) {
+				result[field.id].forEach(res => {
+					let length = 10;
+
+					if (res) {
+						length = res.length + 3;
+					}
+
+					if (!cols[fieldIndex]) {
+						cols[fieldIndex] = Math.max(10, field.columnName.length);
+					}
+
+					if (length > cols[fieldIndex]) {
+						cols[fieldIndex] = length;
+					}
+				});
+			}
+			else {
+				let res = result[field.id];
+				let length = 10;
+
+				if (res !== null && res !== undefined) {
+					const resStr = (typeof res === 'string') ? res : `${res}`;
+					length = resStr.length + 3;
+				}
+
+				if (!cols[fieldIndex]) {
+					cols[fieldIndex] = Math.max(10, field.columnName.length);
+				}
+
+				if (length > cols[fieldIndex]) {
+					cols[fieldIndex] = length;
+				}
+			}
+		});
+	}
+
+	return cols;
+}