@resolveio/server-lib 22.2.34 → 22.2.36

package/src/methods/cron-jobs.ts

@@ -1,2610 +0,0 @@
-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) {
-				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;
-}