@resolveio/server-lib 22.3.221 → 22.3.223

package/methods/cron-jobs.js

@@ -0,0 +1,2475 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCronJobMethods = loadCronJobMethods;
+var axios_1 = require("axios");
+var Excel = require("exceljs");
+var moment = require("moment-timezone");
+var simpl_schema_1 = require("simpl-schema");
+var cron_job_collection_1 = require("../collections/cron-job.collection");
+var communication_metric_collection_1 = require("../collections/communication-metric.collection");
+var file_collection_1 = require("../collections/file.collection");
+var openai_usage_ledger_collection_1 = require("../collections/openai-usage-ledger.collection");
+var report_builder_report_collection_1 = require("../collections/report-builder-report.collection");
+var resolveio_server_app_1 = require("../resolveio-server-app");
+var common_1 = require("../util/common");
+function getFilterTargets(fieldPath, report) {
+    if (!fieldPath) {
+        return [];
+    }
+    if (fieldPath.startsWith('layout_col_')) {
+        var normalized = fieldPath.replace(/^layout_col_/, '');
+        var parts = normalized.split('_');
+        var idx_1 = parseInt(parts[parts.length - 1], 10);
+        if (!isNaN(idx_1)) {
+            var layoutTargets = ((report === null || report === void 0 ? void 0 : report.fields_selected) || [])
+                .filter(function (f) { return f && (f.layoutColumnIndex === idx_1 || (f.id || '').includes("f_layout_".concat(idx_1, "_"))); })
+                .map(function (f) { return f.fieldPath; });
+            if (layoutTargets.length) {
+                return layoutTargets;
+            }
+        }
+    }
+    return [fieldPath];
+}
+function buildFilterExpression(filter, path) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    if (!filter || !filter.condition || (!filter.field && !path)) {
+        return null;
+    }
+    var 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) {
+            var startDate = null;
+            var 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: [(_a = {}, _a[path] = { '$gte': startDate }, _a), (_b = {}, _b[path] = { '$lte': endDate }, _b)] };
+        }
+        return { $and: [(_c = {}, _c[path] = { '$gte': filter.value }, _c), (_d = {}, _d[path] = { '$lte': filter.highValue }, _d)] };
+    }
+    else if (filter.condition === 'nnull') {
+        var and = [];
+        and.push((_e = {}, _e[path] = { '$exists': true }, _e));
+        and.push((_f = {}, _f[path] = { '$ne': null }, _f));
+        if (filter.fieldType === 'String') {
+            and.push((_g = {}, _g[path] = { '$ne': '' }, _g));
+        }
+        return { $and: and };
+    }
+    else if (filter.condition === 'null') {
+        return _h = {}, _h[path] = { '$eq': null }, _h;
+    }
+    else {
+        if (Array.isArray(filter.value)) {
+            if (filter.condition === 'ne') {
+                var and_1 = [];
+                filter.value.forEach(function (filt) {
+                    var _a, _b;
+                    and_1.push((_a = {}, _a[path] = (_b = {}, _b['$' + filter.condition] = (Array.isArray(filt) ? filt[0] : filt), _b), _a));
+                });
+                if (and_1.length > 1) {
+                    return { $and: and_1 };
+                }
+                else {
+                    return and_1[0];
+                }
+            }
+            else {
+                var or_1 = [];
+                filter.value.forEach(function (filt) {
+                    var _a, _b;
+                    or_1.push((_a = {}, _a[path] = (_b = {}, _b['$' + filter.condition] = (Array.isArray(filt) ? filt[0] : filt), _b), _a));
+                });
+                if (or_1.length > 1) {
+                    return { $or: or_1 };
+                }
+                else {
+                    return or_1[0];
+                }
+            }
+        }
+        else {
+            return _j = {}, _j[path] = (_k = {}, _k['$' + filter.condition] = filter.value, _k), _j;
+        }
+    }
+    return null;
+}
+function parseLayoutColIndex(fieldRef) {
+    if (!fieldRef || !fieldRef.startsWith('layout_col_')) {
+        return null;
+    }
+    var normalized = fieldRef.replace(/^layout_col_/, '');
+    var parts = normalized.split('_');
+    var idx = parseInt(parts[parts.length - 1], 10);
+    return isNaN(idx) ? null : idx;
+}
+function resolveLayoutColumnPrimaryLeafId(fieldRef, report) {
+    var idx = parseLayoutColIndex(fieldRef);
+    if (idx === null) {
+        return null;
+    }
+    var candidates = ((report === null || report === void 0 ? void 0 : report.fields_selected) || []).filter(function (f) { return f && typeof f.layoutColumnIndex !== 'undefined' && f.layoutColumnIndex === idx; });
+    if (!candidates.length) {
+        return null;
+    }
+    var root = report === null || report === void 0 ? void 0 : report.collection_root;
+    var preferred = candidates.find(function (c) { return c.collection_name === root || c.layoutCollection === root; }) || candidates[0];
+    return (preferred === null || preferred === void 0 ? void 0 : preferred.id) || null;
+}
+function resolveFieldRefToLeafId(fieldRef, report) {
+    if (!fieldRef) {
+        return null;
+    }
+    if (fieldRef.startsWith('layout_col_')) {
+        return resolveLayoutColumnPrimaryLeafId(fieldRef, report);
+    }
+    return fieldRef;
+}
+function buildCollectionKeysFromReport(report) {
+    var keys = [];
+    if (report === null || report === void 0 ? void 0 : report.collection_root) {
+        keys.push(report.collection_root);
+    }
+    ((report === null || report === void 0 ? void 0 : report.collection_joins) || []).forEach(function (join) {
+        if (!join) {
+            return;
+        }
+        var 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, fields) {
+    if (fields === void 0) { fields = []; }
+    var keys = buildCollectionKeysFromReport(report);
+    return (fields || []).map(function (field, index) {
+        var header = field.columnName || field.fieldName || "Column ".concat(index + 1);
+        var isCustom = (((field === null || field === void 0 ? void 0 : field.id) || (field === null || field === void 0 ? void 0 : field.fieldPath) || '') + '').startsWith('c_') || (field === null || field === void 0 ? void 0 : field.fieldPathName) === 'Custom Field';
+        var mappings = keys.map(function (key) {
+            var 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_".concat(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_".concat(field.id) : "layout_".concat(index),
+            header: header,
+            mappings: mappings
+        };
+    });
+}
+function ensureLayoutHasCustomField(report, layout, customId, columnName, leafValueType) {
+    if (layout === void 0) { layout = []; }
+    if (!layout || !customId) {
+        return;
+    }
+    var hasCustomField = (layout || []).some(function (col) { return ((col === null || col === void 0 ? void 0 : col.mappings) || []).some(function (m) {
+        return (m === null || m === void 0 ? void 0 : m.mode) === 'variable' && (m.fieldId === customId || m.fieldPath === customId);
+    }); });
+    if (hasCustomField) {
+        return;
+    }
+    var keys = buildCollectionKeysFromReport(report);
+    var rootKey = (report === null || report === void 0 ? void 0 : report.collection_root) || '';
+    var header = columnName || customId;
+    var mappings = keys.map(function (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_".concat(customId),
+        header: header,
+        mappings: mappings
+    });
+}
+function ensureLayoutIncludesCustomFields(report, layout) {
+    if (layout === void 0) { layout = []; }
+    var fieldsCustom = (report === null || report === void 0 ? void 0 : report.fields_custom) || [];
+    if (!fieldsCustom.length) {
+        return layout;
+    }
+    fieldsCustom.forEach(function (custom) {
+        ensureLayoutHasCustomField(report, layout, custom === null || custom === void 0 ? void 0 : custom.id, custom === null || custom === void 0 ? void 0 : custom.columnName, custom === null || custom === void 0 ? void 0 : custom.leafValueType);
+    });
+    return layout;
+}
+function getLayoutColumnsFromReport(report) {
+    var layout = [];
+    if ((report === null || report === void 0 ? void 0 : report.fields_layout) && report.fields_layout.length) {
+        layout = (0, common_1.deepCopy)(report.fields_layout);
+    }
+    else {
+        layout = buildLayoutColumnsFromFields(report, (report === null || report === void 0 ? void 0 : report.fields_selected) || []);
+    }
+    return ensureLayoutIncludesCustomFields(report, layout);
+}
+function syncSelectedFieldsFromLayout(report, layoutColumns) {
+    if (layoutColumns === void 0) { layoutColumns = []; }
+    var fields = [];
+    var sourceFields = (0, common_1.deepCopy)((report === null || report === void 0 ? void 0 : report.fields_selected) || []);
+    var byId = new Map();
+    var byPath = new Map();
+    sourceFields.forEach(function (f) {
+        if (f === null || f === void 0 ? void 0 : f.id) {
+            byId.set(f.id, f);
+        }
+        if (f === null || f === void 0 ? void 0 : f.fieldPath) {
+            byPath.set(f.fieldPath, f);
+        }
+    });
+    layoutColumns.forEach(function (col, colIndex) {
+        (col.mappings || []).forEach(function (map, mapIndex) {
+            if (map.mode === 'variable' && map.fieldPath) {
+                var baseField = byId.get(map.fieldId) || byPath.get(map.fieldPath);
+                if (!baseField) {
+                    return;
+                }
+                var clone = (0, common_1.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_".concat(colIndex, "_").concat(mapIndex);
+                clone.layoutCollection = map.collection;
+                clone.layoutColumnIndex = colIndex;
+                if (!map.fieldId) {
+                    map.fieldId = clone.id;
+                }
+                fields.push(clone);
+            }
+        });
+    });
+    return fields;
+}
+function materializeLayoutRow(report, layoutColumns, selectedFields, row) {
+    var materialized = { _id: row === null || row === void 0 ? void 0 : row._id };
+    var hasDataForCollection = function (collection) {
+        if (!collection) {
+            return false;
+        }
+        return (selectedFields || []).some(function (f) {
+            return f.layoutCollection === collection &&
+                row &&
+                Object.prototype.hasOwnProperty.call(row, f.id) &&
+                row[f.id] !== undefined &&
+                row[f.id] !== null &&
+                row[f.id] !== '';
+        });
+    };
+    (layoutColumns || []).forEach(function (col, colIndex) {
+        var values = [];
+        (col.mappings || []).forEach(function (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, layoutRow, colIndex) {
+    if (!layoutRow || layoutRow[colIndex] === undefined || layoutRow[colIndex] === null) {
+        return '';
+    }
+    var cellValues = Array.isArray(layoutRow[colIndex]) ? layoutRow[colIndex] : [layoutRow[colIndex]];
+    var filtered = cellValues.filter(function (v) { return v !== undefined && v !== null && v.value !== undefined && v.value !== null && v.value !== ''; });
+    if (!filtered.length) {
+        return '';
+    }
+    var rootCollection = report === null || report === void 0 ? void 0 : report.collection_root;
+    var preferred = filtered.find(function (v) { return v.collection === rootCollection; }) || filtered[0];
+    var value = preferred === null || preferred === void 0 ? void 0 : 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, selectedFields) {
+    if (!(col === null || col === void 0 ? void 0 : col.mappings)) {
+        return null;
+    }
+    var target = col.mappings.find(function (m) { return m.mode === 'variable' && m.fieldId; });
+    if (!target) {
+        return null;
+    }
+    return (selectedFields || []).find(function (f) { return f.id === target.fieldId; }) || null;
+}
+var 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) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (moment.isMoment(value)) {
+        return value;
+    }
+    if (value instanceof Date || typeof value === 'number') {
+        var m_1 = moment(value);
+        return m_1.isValid() ? m_1 : null;
+    }
+    if (typeof value === 'string' || value instanceof String) {
+        var str = "".concat(value).trim();
+        if (!str) {
+            return null;
+        }
+        var m_2 = moment(str, STRING_DATE_FORMATS, true);
+        if (m_2.isValid()) {
+            return m_2;
+        }
+        var loose = moment(str, STRING_DATE_FORMATS, false);
+        if (loose.isValid()) {
+            return loose;
+        }
+        var jsDateStr = str.replace(/\s*\([^)]*\)\s*$/, '');
+        var 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)) {
+            var fallback = moment(str);
+            return fallback.isValid() ? fallback : null;
+        }
+        return null;
+    }
+    var m = moment(value);
+    return m.isValid() ? m : null;
+}
+function parseExcelNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (typeof value !== 'string') {
+        return null;
+    }
+    var s = value.trim();
+    if (!s) {
+        return null;
+    }
+    var negative = false;
+    var 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;
+    }
+    var num = Number(s);
+    if (!Number.isFinite(num)) {
+        return null;
+    }
+    return negative ? -num : num;
+}
+function isExcelNumericField(field) {
+    return !!field && (field.fieldType === 'Number' ||
+        field.leafValueType === 'Count' ||
+        field.leafValueType === 'Sum' ||
+        field.leafValueType === 'Average');
+}
+function writeExcelCell(cell, value, fieldMeta) {
+    if (value === null || value === undefined) {
+        cell.value = '';
+        return;
+    }
+    if ((fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.fieldType) === 'Date') {
+        var rawValue = Array.isArray(value) ? value.find(function (v) { return v !== null && v !== undefined && v !== ''; }) : value;
+        var m = parseMoment(rawValue);
+        if (m) {
+            var timezone = process.env.TZ_CLIENT;
+            var local = timezone ? moment.tz(m.toDate(), timezone) : m.clone().local();
+            var leafFormatType = fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.leafFormatType;
+            var 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)) {
+        var parsed = parseExcelNumber(value);
+        if (parsed !== null) {
+            cell.value = parsed;
+            if ((fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.leafFormatType) === 'Currency') {
+                cell.numFmt = '"$"#,##0.00;[Red]-"$"#,##0.00';
+            }
+            else if ((fieldMeta === null || fieldMeta === void 0 ? void 0 : fieldMeta.leafFormatType) === 'Number' || (fieldMeta === null || fieldMeta === void 0 ? void 0 : 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) {
+    var keys = Object.keys(row || {});
+    var maxArray = [];
+    for (var 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, report, sorts) {
+    if (sorts === void 0) { sorts = []; }
+    if (!Array.isArray(results) || !results.length) {
+        return;
+    }
+    var groupIds = ((report === null || report === void 0 ? void 0 : report.groups_row) || []).map(function (g) { return g.id; }).filter(Boolean);
+    if (!groupIds.length) {
+        return;
+    }
+    var groupOrderById = {};
+    var leafSorts = [];
+    (sorts || []).forEach(function (s) {
+        if (!(s === null || s === void 0 ? void 0 : s.field)) {
+            return;
+        }
+        if (groupIds.includes(s.field)) {
+            groupOrderById[s.field] = s.order || 'asc';
+        }
+        else {
+            var leafId = resolveFieldRefToLeafId(s.field, report);
+            if (leafId) {
+                leafSorts.push({ leafId: leafId, order: s.order || 'asc' });
+            }
+        }
+    });
+    var compareScalar = function (aVal, bVal, order) {
+        var dir = order === 'desc' ? -1 : 1;
+        var aNull = aVal === null || aVal === undefined || aVal === '';
+        var bNull = bVal === null || bVal === undefined || bVal === '';
+        if (aNull && bNull) {
+            return 0;
+        }
+        if (aNull) {
+            return 1;
+        }
+        if (bNull) {
+            return -1;
+        }
+        var aNum = typeof aVal === 'number' ? aVal : Number(aVal);
+        var bNum = typeof bVal === 'number' ? bVal : Number(bVal);
+        if (!isNaN(aNum) && !isNaN(bNum)) {
+            if (aNum === bNum) {
+                return 0;
+            }
+            return aNum > bNum ? dir : -dir;
+        }
+        var aStr = ('' + aVal).toLowerCase();
+        var bStr = ('' + bVal).toLowerCase();
+        if (aStr === bStr) {
+            return 0;
+        }
+        return aStr > bStr ? dir : -dir;
+    };
+    var selectedIds = ((report === null || report === void 0 ? void 0 : report.fields_selected) || []).map(function (f) { return f.id; }).filter(Boolean);
+    var sortLeafArraysInRow = function (row) {
+        if (!row || !leafSorts.length) {
+            return;
+        }
+        var arraysToReorder = selectedIds.filter(function (id) { return Array.isArray(row[id]); });
+        if (!arraysToReorder.length) {
+            return;
+        }
+        var length = 0;
+        arraysToReorder.forEach(function (id) {
+            length = Math.max(length, row[id].length || 0);
+        });
+        if (length <= 1) {
+            return;
+        }
+        var getArrayVal = function (id, idx) {
+            var arr = row[id];
+            if (!Array.isArray(arr) || !arr.length) {
+                return null;
+            }
+            return arr[idx] !== undefined ? arr[idx] : arr[arr.length - 1];
+        };
+        var indices = Array.from({ length: length }, function (_, i) { return i; });
+        indices.sort(function (i, j) {
+            var e_1, _a;
+            try {
+                for (var leafSorts_1 = __values(leafSorts), leafSorts_1_1 = leafSorts_1.next(); !leafSorts_1_1.done; leafSorts_1_1 = leafSorts_1.next()) {
+                    var s = leafSorts_1_1.value;
+                    var aVal = Array.isArray(row[s.leafId]) ? getArrayVal(s.leafId, i) : row[s.leafId];
+                    var bVal = Array.isArray(row[s.leafId]) ? getArrayVal(s.leafId, j) : row[s.leafId];
+                    var cmp = compareScalar(aVal, bVal, s.order);
+                    if (cmp !== 0) {
+                        return cmp;
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (leafSorts_1_1 && !leafSorts_1_1.done && (_a = leafSorts_1.return)) _a.call(leafSorts_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return 0;
+        });
+        arraysToReorder.forEach(function (id) {
+            row[id] = indices.map(function (idx) { return getArrayVal(id, idx); });
+        });
+    };
+    var sortGroupLevel = function (rows, depth) {
+        if (!Array.isArray(rows) || !rows.length) {
+            return;
+        }
+        var groupId = groupIds[depth];
+        var order = groupOrderById[groupId] || 'asc';
+        rows.sort(function (a, b) { var _a, _b; return compareScalar((_a = a === null || a === void 0 ? void 0 : a._id) === null || _a === void 0 ? void 0 : _a[groupId], (_b = b === null || b === void 0 ? void 0 : b._id) === null || _b === void 0 ? void 0 : _b[groupId], order); });
+        if (depth < groupIds.length - 1) {
+            var childId_1 = groupIds[depth + 1];
+            rows.forEach(function (r) {
+                var children = r ? r[childId_1] : null;
+                if (Array.isArray(children)) {
+                    sortGroupLevel(children, depth + 1);
+                }
+            });
+        }
+        else {
+            rows.forEach(function (r) { return sortLeafArraysInRow(r); });
+        }
+    };
+    sortGroupLevel(results, 0);
+}
+var OPENAI_USAGE_BILLING_ENDPOINT = 'https://backend.resolveio.com/api/openai-usage/report';
+var AI_USAGE_SYNC_JOB_NAME = 'AI Usage Billing Sync';
+var LEGACY_AI_USAGE_SYNC_JOB_NAME = 'OpenAI Usage Billing Sync';
+var OPENAI_USAGE_DEFAULT_LOOKBACK_DAYS = 30;
+var OPENAI_USAGE_DEFAULT_BATCH_SIZE = 500;
+var OPENAI_USAGE_DEFAULT_OVERLAP_MINUTES = 10;
+var COMMUNICATION_METRICS_ENDPOINT = 'https://backend.resolveio.com/api/communication-metrics/report';
+var COMMUNICATION_METRICS_DEFAULT_LOOKBACK_DAYS = 30;
+var COMMUNICATION_METRICS_DEFAULT_BATCH_SIZE = 1000;
+var COMMUNICATION_METRICS_DEFAULT_OVERLAP_MINUTES = 10;
+var toNumberSetting = function (value, fallback, allowZero) {
+    if (allowZero === void 0) { allowZero = false; }
+    var parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return fallback;
+    }
+    if (allowZero && parsed === 0) {
+        return 0;
+    }
+    return parsed > 0 ? Math.floor(parsed) : fallback;
+};
+var normalizeString = function (value) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+};
+var normalizeIdentifier = function (value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+};
+var normalizeDate = function (value) {
+    if (!value) {
+        return null;
+    }
+    var date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return null;
+    }
+    return date;
+};
+var resolveOpenAIUsageSyncConfig = function () {
+    var _a, _b;
+    var config = ((_a = resolveio_server_app_1.ResolveIOServer.getServerConfig) === null || _a === void 0 ? void 0 : _a.call(resolveio_server_app_1.ResolveIOServer)) || {};
+    var 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;
+    var 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);
+    var batchSize = toNumberSetting(config['OPENAI_USAGE_SYNC_BATCH_SIZE'] || process.env.OPENAI_USAGE_SYNC_BATCH_SIZE, OPENAI_USAGE_DEFAULT_BATCH_SIZE);
+    var lookbackDays = toNumberSetting(config['OPENAI_USAGE_SYNC_LOOKBACK_DAYS'] || process.env.OPENAI_USAGE_SYNC_LOOKBACK_DAYS, OPENAI_USAGE_DEFAULT_LOOKBACK_DAYS);
+    var overlapMinutes = toNumberSetting(config['OPENAI_USAGE_SYNC_OVERLAP_MINUTES'] || process.env.OPENAI_USAGE_SYNC_OVERLAP_MINUTES, OPENAI_USAGE_DEFAULT_OVERLAP_MINUTES, true);
+    var enabledRaw = (_b = config['OPENAI_USAGE_SYNC_ENABLED']) !== null && _b !== void 0 ? _b : process.env.OPENAI_USAGE_SYNC_ENABLED;
+    var enabled = typeof enabledRaw === 'string'
+        ? enabledRaw.trim().toLowerCase() !== 'false' && enabledRaw.trim() !== '0'
+        : enabledRaw !== false;
+    return { config: config, endpoint: endpoint, apiKey: apiKey, batchSize: batchSize, lookbackDays: lookbackDays, overlapMinutes: overlapMinutes, enabled: enabled };
+};
+var buildOpenAIUsageQuery = function (cursorAt, cursorId) {
+    var base = {
+        billable: { $ne: false }
+    };
+    if (!cursorId) {
+        base.timestamp = { $gte: cursorAt };
+        return base;
+    }
+    base.$or = [
+        { timestamp: { $gt: cursorAt } },
+        { timestamp: cursorAt, _id: { $gt: cursorId } }
+    ];
+    return base;
+};
+var normalizeUsagePayloadEntry = function (entry) {
+    if (!entry) {
+        return null;
+    }
+    var timestamp = normalizeDate(entry.timestamp);
+    var idClient = normalizeIdentifier(entry.id_client);
+    if (!timestamp || !idClient) {
+        return null;
+    }
+    var 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)
+    };
+};
+var resolveCommunicationMetricsSyncConfig = function () {
+    var _a, _b;
+    var config = ((_a = resolveio_server_app_1.ResolveIOServer.getServerConfig) === null || _a === void 0 ? void 0 : _a.call(resolveio_server_app_1.ResolveIOServer)) || {};
+    var 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;
+    var 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);
+    var batchSize = toNumberSetting(config['COMMUNICATION_METRICS_SYNC_BATCH_SIZE'] || process.env.COMMUNICATION_METRICS_SYNC_BATCH_SIZE, COMMUNICATION_METRICS_DEFAULT_BATCH_SIZE);
+    var lookbackDays = toNumberSetting(config['COMMUNICATION_METRICS_SYNC_LOOKBACK_DAYS'] || process.env.COMMUNICATION_METRICS_SYNC_LOOKBACK_DAYS, COMMUNICATION_METRICS_DEFAULT_LOOKBACK_DAYS);
+    var overlapMinutes = toNumberSetting(config['COMMUNICATION_METRICS_SYNC_OVERLAP_MINUTES'] || process.env.COMMUNICATION_METRICS_SYNC_OVERLAP_MINUTES, COMMUNICATION_METRICS_DEFAULT_OVERLAP_MINUTES, true);
+    var enabledRaw = (_b = config['COMMUNICATION_METRICS_SYNC_ENABLED']) !== null && _b !== void 0 ? _b : process.env.COMMUNICATION_METRICS_SYNC_ENABLED;
+    var enabled = typeof enabledRaw === 'string'
+        ? enabledRaw.trim().toLowerCase() !== 'false' && enabledRaw.trim() !== '0'
+        : enabledRaw !== false;
+    return { config: config, endpoint: endpoint, apiKey: apiKey, batchSize: batchSize, lookbackDays: lookbackDays, overlapMinutes: overlapMinutes, enabled: enabled };
+};
+var buildCommunicationMetricsQuery = function (cursorAt, cursorId) {
+    if (!cursorId) {
+        return { date: { $gte: cursorAt } };
+    }
+    return {
+        $or: [
+            { date: { $gt: cursorAt } },
+            { date: cursorAt, _id: { $gt: cursorId } }
+        ]
+    };
+};
+var normalizeCommunicationMetricEntry = function (entry) {
+    var _a, _b;
+    if (!entry) {
+        return null;
+    }
+    var date = normalizeDate(entry.date || entry.timestamp);
+    var type = normalizeString(entry.type);
+    if (!date || !type) {
+        return null;
+    }
+    var value = Number((_b = (_a = entry.value) !== null && _a !== void 0 ? _a : entry.count) !== null && _b !== void 0 ? _b : 0);
+    if (!Number.isFinite(value) || !value) {
+        return null;
+    }
+    var id = normalizeIdentifier(entry._id) || normalizeIdentifier(entry.id) || '';
+    var unit = normalizeString(entry.unit);
+    var metadata = entry.metadata && typeof entry.metadata === 'object' ? entry.metadata : undefined;
+    return {
+        _id: id || undefined,
+        date: date,
+        type: type,
+        value: value,
+        unit: unit || undefined,
+        metadata: metadata
+    };
+};
+function loadCronJobMethods(methodManager) {
+    methodManager.methods({
+        cronEmailMergedDocsCleanUp: {
+            function: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var files;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, file_collection_1.Files.find({ $and: [{ type: 'Email Merged Docs' }, { createdAt: { $lte: moment().subtract(1, 'day').toDate() } }] })];
+                            case 1:
+                                files = _a.sent();
+                                if (!files.length) return [3 /*break*/, 4];
+                                return [4 /*yield*/, this.callMethod('deleteFiles', files.map(function (file) { return file.key; }))];
+                            case 2:
+                                _a.sent();
+                                return [4 /*yield*/, file_collection_1.Files.deleteMany({ _id: { $in: files.map(function (a) { return a._id; }) } })];
+                            case 3:
+                                _a.sent();
+                                _a.label = 4;
+                            case 4: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        },
+        stuckCronJob: {
+            function: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var fiveMin, cronJobs;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                fiveMin = moment().subtract(5, 'minutes').toDate();
+                                return [4 /*yield*/, cron_job_collection_1.CronJobs.find({ running: true, updatedAt: { $lte: fiveMin } })];
+                            case 1:
+                                cronJobs = _a.sent();
+                                if (!cronJobs.length) return [3 /*break*/, 3];
+                                return [4 /*yield*/, cron_job_collection_1.CronJobs.updateMany({ _id: { $in: cronJobs.map(function (a) { return a._id; }) } }, { $set: { running: false } })];
+                            case 2:
+                                _a.sent();
+                                _a.label = 3;
+                            case 3: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        },
+        cronOpenAIUsageBillingSync: {
+            check: new simpl_schema_1.default({
+                data: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _a, config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled, rootUrl, jobDoc, runData, lastSyncedAt, lastSyncedId, lookbackMs, cursorAt, cursorId, totalSent, cursorMoved, source, i, query, entries, payloadEntries, lastEntry, jobSelector;
+                    var _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _a = resolveOpenAIUsageSyncConfig(), config = _a.config, endpoint = _a.endpoint, apiKey = _a.apiKey, batchSize = _a.batchSize, lookbackDays = _a.lookbackDays, overlapMinutes = _a.overlapMinutes, enabled = _a.enabled;
+                                if (!enabled) {
+                                    return [2 /*return*/, true];
+                                }
+                                rootUrl = normalizeString(config['ROOT_URL']);
+                                if (rootUrl === 'https://resolveio.com' || rootUrl === 'http://localhost:4200') {
+                                    return [2 /*return*/, true];
+                                }
+                                if (!endpoint || !apiKey) {
+                                    console.warn('[AI Usage Sync] Missing endpoint or API key.');
+                                    return [2 /*return*/, false];
+                                }
+                                return [4 /*yield*/, cron_job_collection_1.CronJobs.findOne({
+                                        name: {
+                                            $in: [AI_USAGE_SYNC_JOB_NAME, LEGACY_AI_USAGE_SYNC_JOB_NAME]
+                                        }
+                                    })];
+                            case 1:
+                                jobDoc = _c.sent();
+                                runData = jobDoc === null || jobDoc === void 0 ? void 0 : jobDoc.method_run_data;
+                                lastSyncedAt = normalizeDate(runData === null || runData === void 0 ? void 0 : runData.last_synced_at);
+                                lastSyncedId = normalizeString(runData === null || runData === void 0 ? void 0 : runData.last_synced_id);
+                                lookbackMs = lookbackDays * 24 * 60 * 60 * 1000;
+                                cursorAt = lastSyncedAt || new Date(Date.now() - lookbackMs);
+                                if (lastSyncedAt && overlapMinutes > 0) {
+                                    cursorAt = new Date(cursorAt.getTime() - overlapMinutes * 60 * 1000);
+                                }
+                                cursorId = lastSyncedId;
+                                totalSent = 0;
+                                cursorMoved = false;
+                                source = {
+                                    clientSlug: (_b = resolveio_server_app_1.ResolveIOServer.getClientName) === null || _b === void 0 ? void 0 : _b.call(resolveio_server_app_1.ResolveIOServer),
+                                    clientName: normalizeString(config['CLIENT_NAME']),
+                                    rootUrl: rootUrl,
+                                    reportedAt: new Date(),
+                                    appVersion: process.env.APP_VERSION
+                                };
+                                i = 0;
+                                _c.label = 2;
+                            case 2:
+                                if (!(i < 1000)) return [3 /*break*/, 7];
+                                query = buildOpenAIUsageQuery(cursorAt, cursorId);
+                                return [4 /*yield*/, openai_usage_ledger_collection_1.OpenAIUsageLedger.find(query, {
+                                        sort: { timestamp: 1, _id: 1 },
+                                        limit: batchSize
+                                    })];
+                            case 3:
+                                entries = _c.sent();
+                                if (!entries.length) {
+                                    return [3 /*break*/, 7];
+                                }
+                                payloadEntries = entries
+                                    .map(function (entry) { return normalizeUsagePayloadEntry(entry); })
+                                    .filter(Boolean);
+                                if (!payloadEntries.length) return [3 /*break*/, 5];
+                                return [4 /*yield*/, axios_1.default.post(endpoint, { entries: payloadEntries, source: source }, {
+                                        headers: {
+                                            'Content-Type': 'application/json',
+                                            'X-ResolveIO-OpenAI-Usage-Key': apiKey,
+                                            'X-OpenAI-Usage-Key': apiKey,
+                                            'X-API-Key': apiKey
+                                        },
+                                        timeout: 20000
+                                    })];
+                            case 4:
+                                _c.sent();
+                                totalSent += payloadEntries.length;
+                                _c.label = 5;
+                            case 5:
+                                lastEntry = entries[entries.length - 1];
+                                if (lastEntry) {
+                                    cursorAt = normalizeDate(lastEntry.timestamp) || cursorAt;
+                                    cursorId = normalizeString(lastEntry._id) || cursorId;
+                                    cursorMoved = true;
+                                }
+                                if (entries.length < batchSize) {
+                                    return [3 /*break*/, 7];
+                                }
+                                _c.label = 6;
+                            case 6:
+                                i++;
+                                return [3 /*break*/, 2];
+                            case 7:
+                                if (!cursorMoved) return [3 /*break*/, 9];
+                                jobSelector = (jobDoc === null || jobDoc === void 0 ? void 0 : jobDoc._id)
+                                    ? { _id: jobDoc._id }
+                                    : { name: AI_USAGE_SYNC_JOB_NAME };
+                                return [4 /*yield*/, cron_job_collection_1.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
+                                        }
+                                    })];
+                            case 8:
+                                _c.sent();
+                                _c.label = 9;
+                            case 9: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        },
+        cronCommunicationMetricsSync: {
+            check: new simpl_schema_1.default({
+                data: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function () {
+                return __awaiter(this, void 0, void 0, function () {
+                    var _a, config, endpoint, apiKey, batchSize, lookbackDays, overlapMinutes, enabled, rootUrl, jobDoc, runData, lastSyncedAt, lastSyncedId, lookbackMs, cursorAt, cursorId, totalSent, cursorMoved, source, i, query, entries, payloadEntries, lastEntry;
+                    var _b;
+                    return __generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _a = resolveCommunicationMetricsSyncConfig(), config = _a.config, endpoint = _a.endpoint, apiKey = _a.apiKey, batchSize = _a.batchSize, lookbackDays = _a.lookbackDays, overlapMinutes = _a.overlapMinutes, enabled = _a.enabled;
+                                if (!enabled) {
+                                    return [2 /*return*/, true];
+                                }
+                                rootUrl = normalizeString(config['ROOT_URL']);
+                                if (rootUrl === 'https://resolveio.com' || rootUrl === 'http://localhost:4200') {
+                                    return [2 /*return*/, true];
+                                }
+                                if (!endpoint || !apiKey) {
+                                    console.warn('[Communication Metrics Sync] Missing endpoint or API key.');
+                                    return [2 /*return*/, false];
+                                }
+                                return [4 /*yield*/, cron_job_collection_1.CronJobs.findOne({ name: 'Communication Metrics Sync' })];
+                            case 1:
+                                jobDoc = _c.sent();
+                                runData = jobDoc === null || jobDoc === void 0 ? void 0 : jobDoc.method_run_data;
+                                lastSyncedAt = normalizeDate(runData === null || runData === void 0 ? void 0 : runData.last_synced_at);
+                                lastSyncedId = normalizeString(runData === null || runData === void 0 ? void 0 : runData.last_synced_id);
+                                lookbackMs = lookbackDays * 24 * 60 * 60 * 1000;
+                                cursorAt = lastSyncedAt || new Date(Date.now() - lookbackMs);
+                                if (lastSyncedAt && overlapMinutes > 0) {
+                                    cursorAt = new Date(cursorAt.getTime() - overlapMinutes * 60 * 1000);
+                                }
+                                cursorId = lastSyncedId;
+                                totalSent = 0;
+                                cursorMoved = false;
+                                source = {
+                                    clientSlug: (_b = resolveio_server_app_1.ResolveIOServer.getClientName) === null || _b === void 0 ? void 0 : _b.call(resolveio_server_app_1.ResolveIOServer),
+                                    clientName: normalizeString(config['CLIENT_NAME']),
+                                    rootUrl: rootUrl,
+                                    reportedAt: new Date(),
+                                    appVersion: process.env.APP_VERSION
+                                };
+                                i = 0;
+                                _c.label = 2;
+                            case 2:
+                                if (!(i < 1000)) return [3 /*break*/, 7];
+                                query = buildCommunicationMetricsQuery(cursorAt, cursorId);
+                                return [4 /*yield*/, communication_metric_collection_1.CommunicationMetrics.find(query, {
+                                        sort: { date: 1, _id: 1 },
+                                        limit: batchSize
+                                    })];
+                            case 3:
+                                entries = _c.sent();
+                                if (!entries.length) {
+                                    return [3 /*break*/, 7];
+                                }
+                                payloadEntries = entries
+                                    .map(function (entry) { return normalizeCommunicationMetricEntry(entry); })
+                                    .filter(Boolean);
+                                if (!payloadEntries.length) return [3 /*break*/, 5];
+                                return [4 /*yield*/, axios_1.default.post(endpoint, { entries: payloadEntries, source: 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
+                                    })];
+                            case 4:
+                                _c.sent();
+                                totalSent += payloadEntries.length;
+                                _c.label = 5;
+                            case 5:
+                                lastEntry = entries[entries.length - 1];
+                                if (lastEntry) {
+                                    cursorAt = normalizeDate(lastEntry.date) || cursorAt;
+                                    cursorId = normalizeString(lastEntry._id) || cursorId;
+                                    cursorMoved = true;
+                                }
+                                if (entries.length < batchSize) {
+                                    return [3 /*break*/, 7];
+                                }
+                                _c.label = 6;
+                            case 6:
+                                i++;
+                                return [3 /*break*/, 2];
+                            case 7:
+                                if (!cursorMoved) return [3 /*break*/, 9];
+                                return [4 /*yield*/, cron_job_collection_1.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
+                                        }
+                                    })];
+                            case 8:
+                                _c.sent();
+                                _c.label = 9;
+                            case 9: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        },
+        reportbuilderCronJob: {
+            check: new simpl_schema_1.default({
+                data: {
+                    type: Object,
+                    blackbox: true
+                }
+            }),
+            function: function (data) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var report, layoutColumns_1, selectedFields, fieldsObj_1, selectedFieldsForQuery_1, groupIds_1, userSorts, userSortByField_1, groupSorts, nonGroupSorts, effectiveSorts, sortObj_1, totalsForQuery, rootOptions, filters_1, filterArrayFields_1, filterArrays_1, res, results_1, reportTotals, customFields, exportFields_1, wb, ws_1, currentRow_1, row_1, useLayout_1, headers_1, exportResults, buffer, _a, _b, email, e_2_1, err_1, wb, ws_2, currentRow_2, row, copy, widths_1, i, now, buffer, _c, _d, email, e_3_1, err_2, datedUniqueDates_1, datedUniqueGroups_1, datedData_1, reportTotalGroups_1, reportTotalDates_1, _loop_1, i, tmpResults, wb, ws, currentRow, currentCol_1, row_2, _loop_2, i, i, total, j, field, buffer, _e, _f, email, e_4_1, err_3, err_4;
+                    var e_2, _g, e_3, _h, e_4, _j;
+                    return __generator(this, function (_k) {
+                        switch (_k.label) {
+                            case 0:
+                                if (data && data['active'] === false) {
+                                    return [2 /*return*/, true];
+                                }
+                                return [4 /*yield*/, report_builder_report_collection_1.ReportBuilderReports.findById(data['id_report'])];
+                            case 1:
+                                report = _k.sent();
+                                _k.label = 2;
+                            case 2:
+                                _k.trys.push([2, 43, , 44]);
+                                layoutColumns_1 = getLayoutColumnsFromReport(report);
+                                selectedFields = syncSelectedFieldsFromLayout(report, layoutColumns_1);
+                                report.fields_selected = selectedFields;
+                                report.fields_layout = layoutColumns_1;
+                                (report.fields_selected || []).forEach(function (field, index) {
+                                    if (!(field === null || field === void 0 ? void 0 : field.id)) {
+                                        field.id = "f_".concat(index);
+                                    }
+                                });
+                                (report.fields_custom || []).forEach(function (custom) {
+                                    if (!custom) {
+                                        return;
+                                    }
+                                    if (!custom.selFieldId && custom.id) {
+                                        var match = (report.fields_selected || []).find(function (field) { return field.fieldPath === custom.id; });
+                                        if (match === null || match === void 0 ? void 0 : match.id) {
+                                            custom.selFieldId = match.id;
+                                        }
+                                    }
+                                });
+                                report.fields_selected.forEach(function (field) {
+                                    var _a, _b;
+                                    if (!(field === null || field === void 0 ? void 0 : field.fieldPath)) {
+                                        return;
+                                    }
+                                    var dotPath = field.fieldPath.replace(/\.\$/g, '');
+                                    var fieldData = dotPath.split('.');
+                                    field.fieldPathObj = null;
+                                    for (var i = fieldData.length - 1; i >= 0; i--) {
+                                        if (!field.fieldPathObj) {
+                                            field.fieldPathObj = (_a = {}, _a[fieldData[i]] = 1, _a);
+                                        }
+                                        else {
+                                            field.fieldPathObj = (_b = {}, _b[fieldData[i]] = field.fieldPathObj, _b);
+                                        }
+                                    }
+                                });
+                                if (!((report.fields_selected && report.fields_selected.length) || (report.groups_row && report.groups_row.length))) return [3 /*break*/, 42];
+                                fieldsObj_1 = {};
+                                selectedFieldsForQuery_1 = (report.fields_selected || []).filter(function (field) { return !(((field === null || field === void 0 ? void 0 : field.fieldPath) || '').startsWith('c_')); });
+                                report.fields_sort = report.fields_sort || [];
+                                selectedFieldsForQuery_1.forEach(function (field) {
+                                    if (field.collection_name === report.collection_root && field.fieldPathObj) {
+                                        fieldsObj_1 = (0, common_1.mergeDeep)(fieldsObj_1, field.fieldPathObj);
+                                    }
+                                });
+                                groupIds_1 = (report.groups_row || []).map(function (g) { return g.id; }).filter(Boolean);
+                                userSorts = (report.fields_sort || []).filter(function (s) { return !!s.field; });
+                                userSortByField_1 = {};
+                                userSorts.forEach(function (s) {
+                                    userSortByField_1[s.field] = s;
+                                });
+                                groupSorts = groupIds_1.map(function (id) { return userSortByField_1[id] || { field: id, order: 'asc' }; });
+                                nonGroupSorts = userSorts.filter(function (s) { return !groupIds_1.includes(s.field); });
+                                effectiveSorts = groupIds_1.length ? __spreadArray(__spreadArray([], __read(groupSorts), false), __read(nonGroupSorts), false) : userSorts;
+                                sortObj_1 = null;
+                                if (effectiveSorts.length) {
+                                    sortObj_1 = {};
+                                    effectiveSorts.forEach(function (sortField) {
+                                        var targetField = sortField.field;
+                                        if (!targetField) {
+                                            return;
+                                        }
+                                        if (targetField.startsWith('layout_col_')) {
+                                            var resolved = resolveFieldRefToLeafId(targetField, report);
+                                            targetField = resolved || targetField;
+                                        }
+                                        if (targetField.startsWith('gr_')) {
+                                            sortObj_1['_id.' + targetField] = (sortField.order === 'asc' ? 1 : -1);
+                                        }
+                                        else {
+                                            sortObj_1[targetField] = (sortField.order === 'asc' ? 1 : -1);
+                                        }
+                                    });
+                                }
+                                totalsForQuery = (report.fields_total || []).map(function (total) {
+                                    var mappedFields = (total.fields || [])
+                                        .map(function (ref) {
+                                        if (!ref) {
+                                            return null;
+                                        }
+                                        if (ref.startsWith('layout_col_')) {
+                                            return resolveFieldRefToLeafId(ref, report);
+                                        }
+                                        return ref;
+                                    })
+                                        .filter(function (f) { return !!f; });
+                                    return __assign(__assign({}, total), { fields: mappedFields });
+                                }).filter(function (total) { return (total.fields || []).length; });
+                                report.fields_total = totalsForQuery;
+                                rootOptions = {
+                                    limit: 0,
+                                    skip: 0,
+                                    fields: fieldsObj_1,
+                                    sort: sortObj_1
+                                };
+                                filters_1 = [];
+                                filterArrayFields_1 = [];
+                                filterArrays_1 = [];
+                                selectedFieldsForQuery_1
+                                    .filter(function (f) { return (f.fieldPath || '').includes('.$.'); })
+                                    .forEach(function (sel) {
+                                    if (!filterArrayFields_1.some(function (f) { return (f === null || f === void 0 ? void 0 : f.fieldPath) === sel.fieldPath; })) {
+                                        filterArrayFields_1.push(sel);
+                                    }
+                                });
+                                (report.fields_filter || []).forEach(function (filterAnd) {
+                                    var ors = [];
+                                    var hasArrayTarget = false;
+                                    (filterAnd.ors || []).forEach(function (filter) {
+                                        var targets = getFilterTargets(filter.field, report);
+                                        if (!targets.length) {
+                                            return;
+                                        }
+                                        targets.forEach(function (path) {
+                                            var isArrayTarget = path.includes('.$.');
+                                            var normalizedPath = path.replace(/\.\$/g, '');
+                                            var expr = buildFilterExpression(filter, normalizedPath);
+                                            if (expr) {
+                                                ors.push(expr);
+                                            }
+                                            if (isArrayTarget) {
+                                                hasArrayTarget = true;
+                                                var leaf_1 = selectedFieldsForQuery_1.find(function (a) { return a.fieldPath === path; });
+                                                if (leaf_1 && !filterArrayFields_1.some(function (f) { return (f === null || f === void 0 ? void 0 : f.fieldPath) === leaf_1.fieldPath; })) {
+                                                    filterArrayFields_1.push(leaf_1);
+                                                }
+                                            }
+                                        });
+                                    });
+                                    if (ors.length) {
+                                        var filterObj = { $or: ors };
+                                        if (hasArrayTarget) {
+                                            filterArrays_1.push(filterObj);
+                                        }
+                                        else {
+                                            filters_1.push(filterObj);
+                                        }
+                                    }
+                                });
+                                return [4 /*yield*/, this.callMethod('reportBuilderGetResults', report.type, report.collection_root, rootOptions, filters_1, filterArrays_1, filterArrayFields_1, selectedFieldsForQuery_1, report.fields_custom, report.groups_row, totalsForQuery, report.fields_link, report.id_date_field || null, report.date_interval || null, report.group_type)];
+                            case 3:
+                                res = _k.sent();
+                                if (!(res && res[0])) return [3 /*break*/, 42];
+                                results_1 = res[0].results;
+                                reportTotals = res[0].totals;
+                                if (report.type === 'Group') {
+                                    applyClientGroupSortToData(results_1, report, effectiveSorts);
+                                }
+                                customFields = (report.fields_custom || []).map(function (cust) { return (__assign(__assign({}, cust), { id: cust.selFieldId, fieldType: 'Number', leafValueType: cust.leafValueType || 'Value', leafFormatType: 'Number', columnName: cust.columnName || cust.id, show: true })); });
+                                exportFields_1 = report.fields_selected.filter(function (a) { return a.show; }).concat(customFields);
+                                if (!(report.type === 'List')) return [3 /*break*/, 16];
+                                exportFields_1.forEach(function (field) {
+                                    if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Number') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = result[field.id].toLocaleString();
+                                        });
+                                    }
+                                    else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'String') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (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_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = (0, common_1.round)(result[field.id], 2).toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Boolean' && (!field.leafFormatType || field.leafFormatType === 'Boolean')) {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = result[field.id] === true ? 'True' : 'False';
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Boolean' && field.leafFormatType === 'String') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = result[field.id] === true ? 'Yes' : 'No';
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Boolean' && field.leafFormatType === 'Boolean_Number') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = result[field.id] === true ? 1 : 0;
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Date' && (field.leafFormatType === 'Date')) {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = moment(result[field.id]).format('L');
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Date' && field.leafFormatType === 'Time') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = moment(result[field.id]).format('LT');
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (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_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = moment(result[field.id]).format('LL');
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime_long') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = moment(result[field.id]).format('LLL');
+                                        });
+                                    }
+                                    else if (field.fieldType === 'Date' && field.leafFormatType === 'Timestamp') {
+                                        results_1.filter(function (a) { return a[field.id] !== null && a[field.id] !== undefined; }).forEach(function (result) {
+                                            result[field.id] = moment(result[field.id]).toDate().getTime();
+                                        });
+                                    }
+                                });
+                                wb = new Excel.Workbook();
+                                ws_1 = wb.addWorksheet('RB_1', { views: [{ showGridLines: true }] });
+                                wb.properties.date1904 = false;
+                                wb.calcProperties.fullCalcOnLoad = true;
+                                currentRow_1 = 1;
+                                row_1 = ws_1.getRow(currentRow_1);
+                                row_1.getCell(2).font = {
+                                    name: 'Arial',
+                                    bold: true,
+                                    size: 14
+                                };
+                                row_1.getCell(4).font = {
+                                    name: 'Arial',
+                                    size: 14
+                                };
+                                row_1.getCell(2).value = 'Report Name:';
+                                row_1.getCell(4).value = report.report_name;
+                                currentRow_1 += 1;
+                                row_1 = ws_1.getRow(currentRow_1);
+                                row_1.getCell(2).font = {
+                                    name: 'Arial',
+                                    bold: true,
+                                    size: 14
+                                };
+                                row_1.getCell(4).font = {
+                                    name: 'Arial',
+                                    size: 14
+                                };
+                                row_1.getCell(2).value = 'Run Date:';
+                                row_1.getCell(4).value = moment().format('LLL');
+                                currentRow_1 += 2;
+                                row_1 = ws_1.getRow(currentRow_1);
+                                useLayout_1 = (layoutColumns_1 && layoutColumns_1.length > 0);
+                                headers_1 = [];
+                                report.groups_row.forEach(function (group) {
+                                    headers_1.push(group.columnName);
+                                });
+                                if (useLayout_1) {
+                                    layoutColumns_1.forEach(function (col, idx) {
+                                        headers_1.push(col.header || "Column ".concat(idx + 1));
+                                    });
+                                }
+                                else {
+                                    exportFields_1.forEach(function (field) {
+                                        headers_1.push(field.columnName);
+                                    });
+                                }
+                                headers_1.forEach(function (header, headerIdx) {
+                                    row_1.getCell(headerIdx + 1).value = header;
+                                });
+                                currentRow_1 += 1;
+                                row_1 = ws_1.getRow(currentRow_1);
+                                exportResults = (0, common_1.deepCopy)(results_1 || []);
+                                exportResults.forEach(function (result) {
+                                    var currentCol = 1;
+                                    report.groups_row.forEach(function (group) {
+                                        var _a, _b;
+                                        writeExcelCell(row_1.getCell(currentCol), (_b = (_a = result === null || result === void 0 ? void 0 : result._id) === null || _a === void 0 ? void 0 : _a[group.id]) !== null && _b !== void 0 ? _b : '', group.treeItem);
+                                        currentCol += 1;
+                                    });
+                                    if (useLayout_1) {
+                                        var layoutRow_1 = materializeLayoutRow(report, layoutColumns_1, report.fields_selected, result);
+                                        layoutColumns_1.forEach(function (col, colIdx) {
+                                            var cellValue = getLayoutCellExportValue(report, layoutRow_1, colIdx);
+                                            var primaryFieldMeta = getPrimaryFieldForLayoutColumn(col, report.fields_selected);
+                                            writeExcelCell(row_1.getCell(currentCol), cellValue === undefined ? '' : cellValue, primaryFieldMeta);
+                                            currentCol += 1;
+                                        });
+                                    }
+                                    else {
+                                        exportFields_1.forEach(function (field) {
+                                            var _a;
+                                            writeExcelCell(row_1.getCell(currentCol), (_a = result[field.id]) !== null && _a !== void 0 ? _a : '', field);
+                                            currentCol += 1;
+                                        });
+                                    }
+                                    currentRow_1 += 1;
+                                    row_1 = ws_1.getRow(currentRow_1);
+                                });
+                                _k.label = 4;
+                            case 4:
+                                _k.trys.push([4, 14, , 15]);
+                                return [4 /*yield*/, wb.xlsx.writeBuffer()];
+                            case 5:
+                                buffer = _k.sent();
+                                _k.label = 6;
+                            case 6:
+                                _k.trys.push([6, 11, 12, 13]);
+                                _a = __values(data['emails']), _b = _a.next();
+                                _k.label = 7;
+                            case 7:
+                                if (!!_b.done) return [3 /*break*/, 10];
+                                email = _b.value;
+                                return [4 /*yield*/, this.sendEmail(email, this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name, '', "\n\t\t\t\t\t\t\t\t\t\t\t<b>" + this.serverConfig['CLIENT_NAME'] + " Automated Report</b><br>\n\t\t\t\t\t\t\t\t\t\t\t<b>Report Name: </b>" + report.report_name + "<br>\n\t\t\t\t\t\t\t\t\t\t\t<b>Prepared By: </b>" + data['user'] + "<br><br>\n\t\t\t\t\t\t\t\t\t\t\tAttached are the results of this automated report.<br><br>\n\t\t\t\t\t\t\t\t\t\t\tResolveIO<br><br>", [
+                                        {
+                                            filename: report.report_name + '-' + moment().format('MM-DD-YYYY-hh-mm-A') + '.xlsx',
+                                            content: buffer
+                                        }
+                                    ], this.serverConfig['MAIL_FROM_REPORTS'], '')];
+                            case 8:
+                                _k.sent();
+                                _k.label = 9;
+                            case 9:
+                                _b = _a.next();
+                                return [3 /*break*/, 7];
+                            case 10: return [3 /*break*/, 13];
+                            case 11:
+                                e_2_1 = _k.sent();
+                                e_2 = { error: e_2_1 };
+                                return [3 /*break*/, 13];
+                            case 12:
+                                try {
+                                    if (_b && !_b.done && (_g = _a.return)) _g.call(_a);
+                                }
+                                finally { if (e_2) throw e_2.error; }
+                                return [7 /*endfinally*/];
+                            case 13: return [3 /*break*/, 15];
+                            case 14:
+                                err_1 = _k.sent();
+                                console.log('Error writing excel export', err_1);
+                                return [3 /*break*/, 15];
+                            case 15: return [3 /*break*/, 42];
+                            case 16:
+                                if (!(report.type === 'Group')) return [3 /*break*/, 29];
+                                exportFields_1.forEach(function (field) {
+                                    results_1.forEach(function (result) {
+                                        modifyDataTypeField(report, result, field, 1);
+                                    });
+                                });
+                                wb = new Excel.Workbook();
+                                ws_2 = wb.addWorksheet('RB_1', { views: [{ showGridLines: false }] });
+                                wb.properties.date1904 = false;
+                                wb.calcProperties.fullCalcOnLoad = true;
+                                currentRow_2 = 1;
+                                row = ws_2.getRow(currentRow_2);
+                                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_2 += 1;
+                                row = ws_2.getRow(currentRow_2);
+                                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 += 2;
+                                copy = (0, common_1.deepCopy)(results_1);
+                                widths_1 = [];
+                                copy.forEach(function (res) {
+                                    currentRow_2 = tabGroupExcelRecursive(report, ws_2, currentRow_2, 1, res, exportFields_1);
+                                    tabGroupExcelWidthRecursive(report, 1, res, widths_1, exportFields_1);
+                                });
+                                for (i = 1; i < ws_2.columns.length; i++) {
+                                    ws_2.columns[i].width = widths_1[i - 1];
+                                }
+                                now = new Date();
+                                _k.label = 17;
+                            case 17:
+                                _k.trys.push([17, 27, , 28]);
+                                return [4 /*yield*/, wb.xlsx.writeBuffer()];
+                            case 18:
+                                buffer = _k.sent();
+                                _k.label = 19;
+                            case 19:
+                                _k.trys.push([19, 24, 25, 26]);
+                                _c = __values(data['emails']), _d = _c.next();
+                                _k.label = 20;
+                            case 20:
+                                if (!!_d.done) return [3 /*break*/, 23];
+                                email = _d.value;
+                                return [4 /*yield*/, this.sendEmail(email, this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name, '', "\n\t\t\t\t\t\t\t\t\t\t\t<b>" + this.serverConfig['CLIENT_NAME'] + " Automated Report</b><br>\n\t\t\t\t\t\t\t\t\t\t\t<b>Report Name: </b>" + report.report_name + "<br>\n\t\t\t\t\t\t\t\t\t\t\t<b>Prepared By: </b>" + data['user'] + "<br><br>\n\t\t\t\t\t\t\t\t\t\t\tAttached are the results of this automated report.<br><br>\n\t\t\t\t\t\t\t\t\t\t\tHave a great day!<br><br>\n\t\t\t\t\t\t\t\t\t\t\tResolveIO<br><br>", [
+                                        {
+                                            filename: 'Group_Report_' + report.report_name + '_' + now.getFullYear() + '_' + (now.getMonth() + 1) + '_' + now.getDate() + '.xlsx',
+                                            content: buffer
+                                        }
+                                    ], this.serverConfig['MAIL_FROM_REPORTS'], '')];
+                            case 21:
+                                _k.sent();
+                                _k.label = 22;
+                            case 22:
+                                _d = _c.next();
+                                return [3 /*break*/, 20];
+                            case 23: return [3 /*break*/, 26];
+                            case 24:
+                                e_3_1 = _k.sent();
+                                e_3 = { error: e_3_1 };
+                                return [3 /*break*/, 26];
+                            case 25:
+                                try {
+                                    if (_d && !_d.done && (_h = _c.return)) _h.call(_c);
+                                }
+                                finally { if (e_3) throw e_3.error; }
+                                return [7 /*endfinally*/];
+                            case 26: return [3 /*break*/, 28];
+                            case 27:
+                                err_2 = _k.sent();
+                                console.log('Error writing excel export', err_2);
+                                return [3 /*break*/, 28];
+                            case 28:
+                                ;
+                                return [3 /*break*/, 42];
+                            case 29:
+                                if (!(report.type === 'Dated')) return [3 /*break*/, 42];
+                                datedUniqueDates_1 = [];
+                                datedUniqueGroups_1 = [];
+                                datedData_1 = [];
+                                reportTotalGroups_1 = [];
+                                reportTotalDates_1 = [];
+                                // Step 1: Handle quarterly dates if applicable
+                                if (report.date_interval === 'Quarterly') {
+                                    results_1.forEach(function (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;
+                                    });
+                                    _loop_1 = function (i) {
+                                        var dataPt = results_1[i];
+                                        if (results_1.filter(function (a) { return JSON.stringify(a._id) === JSON.stringify(dataPt._id); }).length > 1) {
+                                            var tmpData_1 = results_1.find(function (a) { return JSON.stringify(a._id) === JSON.stringify(dataPt._id); });
+                                            Object.keys(tmpData_1)
+                                                .filter(function (a) { return a !== '_id'; })
+                                                .forEach(function (key) {
+                                                tmpData_1[key] += dataPt[key];
+                                            });
+                                            results_1.splice(i, 1); // Remove the duplicate entry
+                                        }
+                                    };
+                                    // Deduplicate quarterly data
+                                    for (i = results_1.length - 1; i >= 1; i--) {
+                                        _loop_1(i);
+                                    }
+                                }
+                                tmpResults = (0, common_1.deepCopy)(results_1);
+                                tmpResults.forEach(function (result) {
+                                    delete result._id.day;
+                                    delete result._id.week;
+                                    delete result._id.month;
+                                    delete result._id.quarter;
+                                    delete result._id.year;
+                                    var tmpGroup = {};
+                                    Object.keys(result._id).forEach(function (key) {
+                                        tmpGroup[key] = result._id[key];
+                                    });
+                                    if (!datedUniqueGroups_1.find(function (a) { return JSON.stringify(a) === JSON.stringify(tmpGroup); })) {
+                                        datedUniqueGroups_1.push(tmpGroup);
+                                    }
+                                });
+                                // Step 3: Prepare unique dates
+                                tmpResults = (0, common_1.deepCopy)(results_1);
+                                tmpResults.forEach(function (result) {
+                                    Object.keys(result._id)
+                                        .filter(function (a) { return a !== 'second' && a !== 'hour' && a !== 'minute' && a !== 'day' && a !== 'week' && a !== 'month' && a !== 'quarter' && a !== 'year'; })
+                                        .forEach(function (key) {
+                                        delete result._id[key];
+                                    });
+                                    var tmpDate = {};
+                                    Object.keys(result._id).forEach(function (key) {
+                                        tmpDate[key] = result._id[key];
+                                    });
+                                    if (!datedUniqueDates_1.find(function (a) { return JSON.stringify(a) === JSON.stringify(tmpDate); })) {
+                                        datedUniqueDates_1.push(tmpDate);
+                                    }
+                                });
+                                // Build the date strings
+                                // Ensure moment is using America/Chicago timezone for all date processing
+                                datedUniqueDates_1.forEach(function (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_1 = datedUniqueDates_1.filter(function (a) { return !a.date; })
+                                    .concat(datedUniqueDates_1.filter(function (a) { return a.date; }).sort(function (a, b) { return a.date.getTime() - b.date.getTime(); }));
+                                // Step 4: Build datedData and reportTotalGroups
+                                datedUniqueDates_1.forEach(function (date) {
+                                    var tmpData = [];
+                                    var tmpTotalDated = {};
+                                    var tmpTotalCnt = {};
+                                    var tmpTotalType = {};
+                                    datedUniqueGroups_1.forEach(function (group) {
+                                        var result = results_1.find(function (a) {
+                                            var match = true;
+                                            // Match the group fields
+                                            Object.keys(group).forEach(function (key) {
+                                                if (a._id[key] !== group[key]) {
+                                                    match = false;
+                                                }
+                                            });
+                                            // Match the date fields
+                                            Object.keys(date).filter(function (key) { return key !== 'date' && key !== 'dateLast' && key !== 'dateString'; }).forEach(function (key) {
+                                                if (a._id[key] !== date[key]) {
+                                                    match = false;
+                                                }
+                                            });
+                                            return match;
+                                        });
+                                        if (result) {
+                                            tmpData.push(result);
+                                            Object.keys(result._id).filter(function (a) { return a; }).forEach(function (key) {
+                                                if (report.fields_total.filter(function (a) { return 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(function (a) { return a.fields.includes(key); }).type;
+                                                }
+                                            });
+                                            Object.keys(result).filter(function (a) { return a && a !== '_id'; }).forEach(function (key) {
+                                                if (report.fields_total.filter(function (a) { return 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(function (a) { return a.fields.includes(key); }).type;
+                                                }
+                                            });
+                                        }
+                                        else {
+                                            tmpData.push(null);
+                                        }
+                                    });
+                                    // Handle averaging for totals
+                                    Object.keys(tmpTotalType).forEach(function (totalKey) {
+                                        if (tmpTotalType[totalKey] === 'avg') {
+                                            tmpTotalDated[totalKey] = tmpTotalDated[totalKey] / tmpTotalCnt[totalKey];
+                                        }
+                                        tmpTotalDated[totalKey] = (0, common_1.round)(tmpTotalDated[totalKey], 2);
+                                    });
+                                    reportTotalDates_1.push(tmpTotalDated);
+                                    datedData_1.push(tmpData);
+                                });
+                                // Calculate group-level totals
+                                datedUniqueGroups_1.forEach(function (group) {
+                                    var tmpTotalGroup = {};
+                                    var filteredData = results_1.filter(function (a) {
+                                        var match = (!Object.keys(group).length || group._id === null) ? false : true;
+                                        Object.keys(group).filter(function (a) { return a !== 'date' && a !== 'dateLast' && a !== 'dateString' && a !== 'second' && a !== 'minute' && a !== 'hour' && a !== 'day' && a !== 'week' && a !== 'month' && a !== 'quarter' && a !== 'year'; }).forEach(function (key) {
+                                            if (a._id[key] !== group[key]) {
+                                                match = false;
+                                            }
+                                        });
+                                        return match;
+                                    });
+                                    report.fields_total.forEach(function (total) {
+                                        total.fields.forEach(function (field) {
+                                            if (filteredData.length) {
+                                                tmpTotalGroup[field] = filteredData.filter(function (a) { return a && a[field]; })
+                                                    .map(function (a) { return a[field]; })
+                                                    .reduce(function (a, b) { return a + b; }, 0);
+                                                if (total.type === 'avg') {
+                                                    tmpTotalGroup[field] = (0, common_1.round)(tmpTotalGroup[field] / filteredData.length, 2);
+                                                }
+                                            }
+                                            else {
+                                                tmpTotalGroup[field] = 0;
+                                            }
+                                        });
+                                    });
+                                    reportTotalGroups_1.push(tmpTotalGroup);
+                                });
+                                wb = new Excel.Workbook();
+                                ws = wb.addWorksheet('Dated_Report', { views: [{ showGridLines: true }] });
+                                wb.properties.date1904 = false;
+                                wb.calcProperties.fullCalcOnLoad = true;
+                                currentRow = 1;
+                                currentCol_1 = 1;
+                                row_2 = ws.getRow(currentRow);
+                                row_2.getCell(2).font = {
+                                    name: 'Arial',
+                                    bold: true,
+                                    size: 14
+                                };
+                                row_2.getCell(4).font = {
+                                    name: 'Arial',
+                                    size: 14
+                                };
+                                row_2.getCell(2).value = 'Report Name:';
+                                row_2.getCell(4).value = report.report_name;
+                                currentRow += 1;
+                                row_2 = ws.getRow(currentRow);
+                                row_2.getCell(2).font = {
+                                    name: 'Arial',
+                                    bold: true,
+                                    size: 14
+                                };
+                                row_2.getCell(4).font = {
+                                    name: 'Arial',
+                                    size: 14
+                                };
+                                row_2.getCell(2).value = 'Run Date:';
+                                row_2.getCell(4).value = moment().format('LLL');
+                                currentRow += 2;
+                                row_2 = ws.getRow(currentRow);
+                                // Add group column headers
+                                report.groups_row.forEach(function (group) {
+                                    row_2.getCell(currentCol_1).value = group.columnName;
+                                    currentCol_1++;
+                                });
+                                // Add field headers
+                                currentCol_1 += report.fields_selected.filter(function (a) { return a.show; }).length;
+                                // Add the date interval headers
+                                report.fields_selected.filter(function (a) { return a.show; }).forEach(function () {
+                                    datedUniqueDates_1.forEach(function (date) {
+                                        row_2.getCell(currentCol_1).value = date.dateString;
+                                        currentCol_1++;
+                                    });
+                                });
+                                // Add totals headers
+                                report.fields_total.forEach(function (total) {
+                                    row_2.getCell(currentCol_1).value = 'Totals - ' + (0, common_1.toTitleCase)(total.type);
+                                    currentCol_1++;
+                                });
+                                currentCol_1 = 1;
+                                currentRow += 1;
+                                row_2 = ws.getRow(currentRow);
+                                _loop_2 = function (i) {
+                                    var group = datedUniqueGroups_1[i];
+                                    var _loop_3 = function (j) {
+                                        var field = report.fields_selected.filter(function (a) { return a.show; })[j];
+                                        currentCol_1 = 1;
+                                        row_2 = ws.getRow(currentRow);
+                                        // Populate group data
+                                        report.groups_row.forEach(function (groupRow) {
+                                            row_2.getCell(currentCol_1).value = (j === 0) ? group[groupRow.id] : '';
+                                            currentCol_1++;
+                                        });
+                                        // Populate field data
+                                        row_2.getCell(currentCol_1).value = field.columnName;
+                                        currentCol_1++;
+                                        // Populate date interval data for each field
+                                        for (var k = 0; k < datedUniqueDates_1.length; k++) {
+                                            var result = datedData_1[k];
+                                            if (result[i]) {
+                                                row_2.getCell(currentCol_1).value = result[i][field.id] ? result[i][field.id] : '';
+                                            }
+                                            else {
+                                                row_2.getCell(currentCol_1).value = '';
+                                            }
+                                            currentCol_1++;
+                                        }
+                                        // Add totals for each field in the report
+                                        for (var k = 0; k < report.fields_total.length; k++) {
+                                            row_2.getCell(currentCol_1).value = reportTotalGroups_1[i][field.id] ? reportTotalGroups_1[i][field.id] : '';
+                                            currentCol_1++;
+                                        }
+                                        currentRow++; // Move to the next row for the next field
+                                    };
+                                    for (var j = 0; j < report.fields_selected.filter(function (a) { return a.show; }).length; j++) {
+                                        _loop_3(j);
+                                    }
+                                };
+                                // Populate data for each group and field with date intervals
+                                for (i = 0; i < datedUniqueGroups_1.length; i++) {
+                                    _loop_2(i);
+                                }
+                                // Add report totals at the bottom
+                                if (reportTotals) {
+                                    for (i = 0; i < report.fields_total.length; i++) {
+                                        total = report.fields_total[i];
+                                        row_2 = ws.getRow(currentRow);
+                                        currentCol_1 = 1;
+                                        row_2.getCell(currentCol_1).value = (0, common_1.toTitleCase)(total.type) + ' Totals';
+                                        currentCol_1 += report.groups_row.length; // Skip group columns
+                                        // Skip the date columns for the totals row
+                                        report.fields_selected.filter(function (a) { return a.show; }).forEach(function () {
+                                            currentCol_1 += 1;
+                                        });
+                                        datedUniqueDates_1.forEach(function () {
+                                            currentCol_1++;
+                                        });
+                                        // Set totals in the correct fields
+                                        for (j = 0; j < report.fields_selected.filter(function (a) { return a.show; }).length; j++) {
+                                            field = report.fields_selected.filter(function (a) { return a.show; })[j];
+                                            row_2.getCell(currentCol_1).value = reportTotals[total.id + '_' + field.id] || '';
+                                            currentCol_1++;
+                                        }
+                                        currentRow++; // Move to the next row for the next total
+                                    }
+                                }
+                                _k.label = 30;
+                            case 30:
+                                _k.trys.push([30, 40, , 41]);
+                                return [4 /*yield*/, wb.xlsx.writeBuffer()];
+                            case 31:
+                                buffer = _k.sent();
+                                _k.label = 32;
+                            case 32:
+                                _k.trys.push([32, 37, 38, 39]);
+                                _e = __values(data['emails']), _f = _e.next();
+                                _k.label = 33;
+                            case 33:
+                                if (!!_f.done) return [3 /*break*/, 36];
+                                email = _f.value;
+                                return [4 /*yield*/, this.sendEmail(email, this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name, '', "\n\t\t\t\t\t\t\t\t\t\t\t<b>".concat(this.serverConfig['CLIENT_NAME'], " Automated Report</b><br>\n\t\t\t\t\t\t\t\t\t\t\t<b>Report Name: </b>").concat(report.report_name, "<br>\n\t\t\t\t\t\t\t\t\t\t\t<b>Prepared By: </b>").concat(data['user'], "<br><br>\n\t\t\t\t\t\t\t\t\t\t\tAttached are the results of this automated report.<br><br>\n\t\t\t\t\t\t\t\t\t\t\tResolveIO<br><br>"), [
+                                        {
+                                            filename: report.report_name + '-' + moment().format('MM-DD-YYYY-hh-mm-A') + '.xlsx',
+                                            content: buffer
+                                        }
+                                    ], this.serverConfig['MAIL_FROM_REPORTS'], '')];
+                            case 34:
+                                _k.sent();
+                                _k.label = 35;
+                            case 35:
+                                _f = _e.next();
+                                return [3 /*break*/, 33];
+                            case 36: return [3 /*break*/, 39];
+                            case 37:
+                                e_4_1 = _k.sent();
+                                e_4 = { error: e_4_1 };
+                                return [3 /*break*/, 39];
+                            case 38:
+                                try {
+                                    if (_f && !_f.done && (_j = _e.return)) _j.call(_e);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                                return [7 /*endfinally*/];
+                            case 39: return [3 /*break*/, 41];
+                            case 40:
+                                err_3 = _k.sent();
+                                console.log('Error writing excel export', err_3);
+                                return [3 /*break*/, 41];
+                            case 41: return [2 /*return*/, true];
+                            case 42: return [3 /*break*/, 44];
+                            case 43:
+                                err_4 = _k.sent();
+                                err_4.message = "Error in Report Builder Cron Job - Report Builder Build Tree: ".concat(err_4.message);
+                                throw err_4;
+                            case 44: return [2 /*return*/, true];
+                        }
+                    });
+                });
+            }
+        }
+    });
+}
+function modifyDataTypeField(report, result, field, index) {
+    var processFieldValue = function (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 (0, common_1.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;
+    };
+    var processArrayField = function (array, field) {
+        return array.map(function (value) { return processFieldValue(value, field); });
+    };
+    if (index < report.groups_row.length) {
+        // Handle grouped data
+        var groupKey = 'gr_' + (index + 1);
+        if (result[groupKey]) {
+            result[groupKey].forEach(function (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, currentRow, level, result, fields) {
+    var row = ws.getRow(currentRow);
+    var 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
+        };
+        var 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(function (total) {
+                currentRow += 1;
+                row = ws.getRow(currentRow);
+                fields.forEach(function (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(function (total) {
+            currentRow += 1;
+            row = ws.getRow(currentRow);
+            fields.forEach(function (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;
+        var nextGroup = report.groups_row[level];
+        if (nextGroup) {
+            var nextResults = result[nextGroup.id];
+            if (Array.isArray(nextResults)) {
+                nextResults.forEach(function (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
+        };
+        var 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(function (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(function (res, resIndex) {
+            currentRow += 1;
+            row = ws.getRow(currentRow);
+            fields.forEach(function (field, fieldIndex) {
+                var 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(function (total) {
+            currentRow += 1;
+            row = ws.getRow(currentRow);
+            fields.forEach(function (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) {
+        var nextGroup = report.groups_row[level];
+        if (nextGroup) {
+            var nextResults = result[nextGroup.id];
+            if (Array.isArray(nextResults)) {
+                nextResults.forEach(function (tDataRes) {
+                    cols = tabGroupExcelWidthRecursive(report, level + 1, tDataRes, cols, fields);
+                });
+            }
+        }
+    }
+    else {
+        fields.forEach(function (field, fieldIndex) {
+            if (Array.isArray(result[field.id])) {
+                result[field.id].forEach(function (res) {
+                    var 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 {
+                var res = result[field.id];
+                var length_1 = 10;
+                if (res !== null && res !== undefined) {
+                    var resStr = (typeof res === 'string') ? res : "".concat(res);
+                    length_1 = resStr.length + 3;
+                }
+                if (!cols[fieldIndex]) {
+                    cols[fieldIndex] = Math.max(10, field.columnName.length);
+                }
+                if (length_1 > cols[fieldIndex]) {
+                    cols[fieldIndex] = length_1;
+                }
+            }
+        });
+    }
+    return cols;
+}
+
+//# sourceMappingURL=cron-jobs.js.map