@resolveio/server-lib 12.5.52 → 12.5.54

package/src/methods/cron-jobs.ts

@@ -0,0 +1,1454 @@
+import { MethodManager } from '../managers/method.manager';
+import { ReportBuilderReports } from '../collections/report-builder-report.collection';
+import SimpleSchema from 'simpl-schema';
+import { mergeDeep, deepCopy, toTitleCase } from '../util/common';
+import { PaginationOptions } from '../models/pagination.model';
+import * as moment from 'moment';
+import * as XLSX from 'xlsx';
+import * as Excel from 'exceljs';
+import { Files } from '../collections/file.collection';
+
+export function loadCronJobMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		cronEmailMergedDocsCleanUp: {
+			function: function() {
+				return new Promise(async (resolve, reject) => {
+					let files = await Files.find({$and: [{type: 'Email Merged Docs'}, {createdAt: {$lte: moment().subtract(1, 'day').toDate()}}]});
+					
+					if (files.length) {
+						this.callMethodInternal('deleteFiles');
+						Files.deleteMany({_id: {$in: files.map(a => a._id)}});
+					}
+
+					resolve(true);
+				});
+			}
+		},
+		reportbuilderCronJob: {
+			check: new SimpleSchema({
+				data: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: function(data: Object) {
+				return new Promise(async (resolve, reject) => {
+					let report = await ReportBuilderReports.findById(data['id_report']);
+
+					report.fields_selected.forEach((field: any) => {
+						let dotPath = field.fieldPath.replace(/\.\$/g, '');
+						let fieldData = dotPath.split('.');
+						field.fieldPathObj = null;
+						for (let i = fieldData.length - 1; i >= 0; i--) {
+							if (!field.fieldPathObj) {
+								field.fieldPathObj = {[fieldData[i]]: 1};
+							}
+							else {
+								field.fieldPathObj = {[fieldData[i]]: field.fieldPathObj};
+							}
+						}
+					});
+
+					if ((report.fields_selected && report.fields_selected.length) || (report.groups_row && report.groups_row.length)) {
+						let fieldsObj = {};
+
+						let count = 0;
+
+						report.fields_selected.forEach((field: any) => {
+							if (field.collection_name === report.collection_root) {
+								fieldsObj = mergeDeep(fieldsObj, field.fieldPathObj);
+							}
+							
+							let sortIndex = report.fields_sort.findIndex(a => a.field === field['id']);
+
+							if (sortIndex >= 0) {
+								report.fields_sort[sortIndex].field = ('f_' + count);
+							}
+
+							field['id'] = 'f_' + count;
+
+							count += 1;
+						});
+
+						let sortObj = {};
+						if (report.fields_sort.length) {
+							report.fields_sort.forEach(sortField => {
+								if (sortField.field.startsWith('gr_')) {
+									sortObj['_id.' + sortField.field] = (sortField.order === 'asc' ? 1 : -1);
+								}
+								else {
+									sortObj[sortField.field] = (sortField.order === 'asc' ? 1 : -1);
+								}
+							});
+						}
+						else {
+							sortObj = null;
+						}
+
+						let rootOptions: PaginationOptions = {
+							limit: 0,
+							skip: 0,
+							fields: fieldsObj,
+							sort: sortObj
+						};
+
+						let filters = [];
+						report.fields_filter.forEach(filterAnd => {
+							let ors = [];
+							filterAnd.ors.filter(a => !a.field.includes('.$.')).forEach(filter => {
+								if (filter.condition && filter.field && ((filter.value !== null && (!Array.isArray(filter.value) || filter.value.length)) || filter.condition === 'null' || filter.condition === 'nnull')) {
+									if (filter.condition === 'bw') {
+										if (filter.fieldType === 'Date' && filter.is_rolling) {
+											let startDate = null;
+											let endDate = null;
+
+											if (filter.rolling_interval === 'Q1') {
+												startDate = moment().startOf('year').toDate();
+												endDate = moment().startOf('year').quarter(2).subtract(1, 'days').toDate();
+											}
+											else if (filter.rolling_interval === 'Q2') {
+												startDate = moment().startOf('year').quarter(2).toDate();
+												endDate = moment().startOf('year').quarter(3).subtract(1, 'days').toDate();
+											}
+											else if (filter.rolling_interval === 'Q3') {
+												startDate = moment().startOf('year').quarter(3).toDate();
+												endDate = moment().startOf('year').quarter(4).subtract(1, 'days').toDate();
+											}
+											else if (filter.rolling_interval === 'Q4') {
+												startDate = moment().startOf('year').quarter(4).toDate();
+												endDate = moment().endOf('year').toDate();
+											}
+											else if (filter.rolling_interval === 'Today') {
+												startDate = moment().startOf('day').toDate();
+												endDate = moment().endOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Yesterday') {
+												startDate = moment().subtract(1, 'days').startOf('day').toDate();
+												endDate = moment().subtract(1, 'days').endOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Week') {
+												startDate = moment().startOf('isoWeek').toDate();
+												endDate = moment().endOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Last Week') {
+												endDate = moment().startOf('isoWeek').subtract(1, 'days').toDate();
+												startDate = moment(endDate).startOf('isoWeek').toDate();
+											}
+											else if (filter.rolling_interval === 'Month') {
+												startDate = moment().startOf('month').toDate();
+												endDate = moment().endOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Last Month') {
+												endDate = moment().startOf('month').subtract(1, 'days').endOf('day').toDate();
+												startDate = moment(endDate).startOf('month').toDate();
+											}
+											else if (filter.rolling_interval === 'Last 30 Days') {
+												endDate = moment().endOf('day').toDate();
+												startDate = moment().subtract(30, 'days').startOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Quarter') {
+												startDate = moment().startOf('year').quarter(moment().quarter()).toDate();
+												endDate = moment().endOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Last Quarter') {
+												endDate = moment().startOf('year').quarter(moment().quarter()).subtract(1, 'days').endOf('day').toDate();
+												startDate = moment(endDate).startOf('quarter').toDate();
+											}
+											else if (filter.rolling_interval === 'Year') {
+												startDate = moment().startOf('year').toDate();
+												endDate = moment().endOf('day').toDate();
+											}
+											else if (filter.rolling_interval === 'Last Year') {
+												endDate = moment().startOf('year').subtract(1, 'days').endOf('day').toDate();
+												startDate = moment(endDate).startOf('year').toDate();
+											}
+											else if (filter.rolling_interval === 'All') {
+												startDate = new Date(2017, 0, 1, 0, 0, 0, 0);
+												endDate = moment().endOf('day').toDate();
+											}
+
+											endDate.setHours(23);
+											endDate.setMinutes(59);
+											endDate.setSeconds(59);
+											endDate.setMilliseconds(999);
+
+											ors.push({$and: [{[filter.field]: {'$gte': startDate}}, {[filter.field]: {'$lte': endDate}}]});
+										}
+										else {
+											ors.push({$and: [{[filter.field]: {'$gte': filter.value}}, {[filter.field]: {'$lte': filter.highValue}}]});
+										}
+									}
+									else if (filter.condition === 'nnull') {
+										let and = [];
+										and.push({[filter.field]: {'$exists': true}});
+										and.push({[filter.field]: {'$ne': null}});
+										
+										if (filter.fieldType === 'String') {
+											and.push({[filter.field]: {'$ne': ''}});
+										}
+
+										ors.push({$and: and});
+									}
+									else if (filter.condition === 'null') {
+										ors.push({[filter.field]: {'$eq': null}});
+									}
+									else {
+										if (Array.isArray(filter.value)) {
+											if (filter.condition === 'ne') {
+												let and = [];
+												filter.value.forEach(filt => {
+													and.push({[filter.field]: {['$' + filter.condition]: (Array.isArray(filt) ? filt[0] : filt)}});
+												});
+
+												if (and.length > 1) {
+													ors.push({$and: and});
+												}
+												else {
+													ors.push(and[0]);
+												}
+											}
+											else {
+												let or = [];
+				
+												filter.value.forEach(filt => {
+													or.push({[filter.field]: {['$' + filter.condition]: (Array.isArray(filt) ? filt[0] : filt)}});
+												});
+					
+												if (or.length > 1) {
+													ors.push({$or: or});
+												}
+												else {
+													ors.push(or[0]);
+												}
+											}
+										}
+										else {
+											ors.push({[filter.field]: {['$' + filter.condition]: filter.value}});
+										}
+									}
+								}
+							});
+
+							if (ors.length) {
+								filters.push({$or: ors});
+							}
+						});
+
+						this.callMethodInternal('reportBuilderBuildTree', report.collection_root, (errCollTree, collectionTree) => {
+							if (collectionTree) {
+								collectionTree.layers = [collectionTree];
+				
+								let treeLeaves = [];
+								let allLeaves = [];
+								getTreeLeaves(collectionTree.children, treeLeaves);
+								getTreeLeaves(collectionTree.children, allLeaves, true);
+
+								let filterArrayFields = [];
+								let filterArrays = [];
+								report.fields_filter.forEach(filterAnd => {
+									let ors = [];
+									filterAnd.ors.filter(a => a.field.includes('.$.')).forEach(filter => {
+										if (allLeaves.filter(a => a.fieldPath === filter.field)[0]) {
+											filterArrayFields.push(allLeaves.filter(a => a.fieldPath === filter.field)[0]);
+										}
+
+										if (filter.condition && filter.field && ((filter.value !== null && (!Array.isArray(filter.value) || filter.value.length)) || filter.condition === 'null' || filter.condition === 'nnull')) {
+											if (filter.condition === 'bw') {
+												if (filter.fieldType === 'Date' && filter.is_rolling) {
+													let startDate = null;
+													let endDate = null;
+
+													if (filter.rolling_interval === 'Q1') {
+														startDate = moment().startOf('year').toDate();
+														endDate = moment().startOf('year').quarter(2).subtract(1, 'days').toDate();
+													}
+													else if (filter.rolling_interval === 'Q2') {
+														startDate = moment().startOf('year').quarter(2).toDate();
+														endDate = moment().startOf('year').quarter(3).subtract(1, 'days').toDate();
+													}
+													else if (filter.rolling_interval === 'Q3') {
+														startDate = moment().startOf('year').quarter(3).toDate();
+														endDate = moment().startOf('year').quarter(4).subtract(1, 'days').toDate();
+													}
+													else if (filter.rolling_interval === 'Q4') {
+														startDate = moment().startOf('year').quarter(4).toDate();
+														endDate = moment().endOf('year').toDate();
+													}
+													else if (filter.rolling_interval === 'Today') {
+														startDate = moment().startOf('day').toDate();
+														endDate = moment().endOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Yesterday') {
+														startDate = moment().subtract(1, 'days').startOf('day').toDate();
+														endDate = moment().subtract(1, 'days').endOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Week') {
+														startDate = moment().startOf('isoWeek').toDate();
+														endDate = moment().endOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Last Week') {
+														endDate = moment().startOf('isoWeek').subtract(1, 'days').toDate();
+														startDate = moment(endDate).startOf('isoWeek').toDate();
+													}
+													else if (filter.rolling_interval === 'Month') {
+														startDate = moment().startOf('month').toDate();
+														endDate = moment().endOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Last Month') {
+														endDate = moment().startOf('month').subtract(1, 'days').endOf('day').toDate();
+														startDate = moment(endDate).startOf('month').toDate();
+													}
+													else if (filter.rolling_interval === 'Last 30 Days') {
+														endDate = moment().endOf('day').toDate();
+														startDate = moment().subtract(30, 'days').startOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Quarter') {
+														startDate = moment().startOf('year').quarter(moment().quarter()).toDate();
+														endDate = moment().endOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Last Quarter') {
+														endDate = moment().startOf('year').quarter(moment().quarter()).subtract(1, 'days').endOf('day').toDate();
+														startDate = moment(endDate).startOf('quarter').toDate();
+													}
+													else if (filter.rolling_interval === 'Year') {
+														startDate = moment().startOf('year').toDate();
+														endDate = moment().endOf('day').toDate();
+													}
+													else if (filter.rolling_interval === 'Last Year') {
+														endDate = moment().startOf('year').subtract(1, 'days').endOf('day').toDate();
+														startDate = moment(endDate).startOf('year').toDate();
+													}
+													else if (filter.rolling_interval === 'All') {
+														startDate = new Date(2017, 0, 1, 0, 0, 0, 0);
+														endDate = moment().endOf('day').toDate();
+													}
+													endDate.setHours(23);
+													endDate.setMinutes(59);
+													endDate.setSeconds(59);
+													endDate.setMilliseconds(999);
+
+													ors.push({$and: [{[filter.field.replace(/\.\$/g, '')]: {'$gte': startDate}}, {[filter.field.replace(/\.\$/g, '')]: {'$lte': endDate}}]});
+												}
+												else {
+													filterArrays.push({$and: [{[filter.field.replace(/\.\$/g, '')]: {'$gte': filter.value}}, {[filter.field.replace(/\.\$/g, '')]: {'$lte': filter.highValue}}]});
+												}
+											}
+											else if (filter.condition === 'nnull') {
+												let and = [];
+												and.push({[filter.field.replace(/\.\$/g, '')]: {'$exists': true}});
+												and.push({[filter.field.replace(/\.\$/g, '')]: {'$ne': null}});
+								
+												if (filter.fieldType === 'String') {
+													and.push({[filter.field.replace(/\.\$/g, '')]: {'$ne': ''}});
+												}
+								
+												ors.push({$and: and});
+											}
+											else if (filter.condition === 'null') {
+												ors.push({[filter.field.replace(/\.\$/g, '')]: {'$eq': null}});
+											}
+											else {
+												if (Array.isArray(filter.value)) {
+													if (filter.condition === 'ne') {
+														let and = [];
+														filter.value.forEach(filt => {
+															and.push({[filter.field.replace(/\.\$/g, '')]: {['$' + filter.condition]: (Array.isArray(filt) ? filt[0] : filt)}});
+														});
+								
+														if (and.length > 1) {
+															ors.push({$and: and});
+														}
+														else {
+															ors.push(and[0]);
+														}
+													}
+													else {
+														let or = [];
+								
+														filter.value.forEach(filt => {
+															or.push({[filter.field.replace(/\.\$/g, '')]: {['$' + filter.condition]: (Array.isArray(filt) ? filt[0] : filt)}});
+														});
+								
+														if (or.length > 1) {
+															ors.push({$or: or});
+														}
+														else {
+															ors.push(or[0]);
+														}
+													}
+												}
+												else {
+													ors.push({[filter.field.replace(/\.\$/g, '')]: {['$' + filter.condition]: filter.value}});
+												}
+											}
+										}
+									});
+
+									if (ors.length) {
+										filterArrays.push({$or: ors});
+									}
+								});
+
+								this.callMethodInternal('reportBuilderGetResults', report.type, report.collection_root, rootOptions, filters, filterArrays, filterArrayFields, report.fields_selected, report.fields_custom, report.groups_row, report.fields_total, report.fields_link, report.id_date_field || null, report.date_interval || null,  report.group_type, (err, res) => {
+									if (res && res[0]) {
+										let results = res[0].results;
+										let reportTotals = res[0].totals;
+								
+										if (report.type === 'List') {
+											report.fields_selected.filter(a => a.show).forEach(field => {
+												if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Number') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined ).forEach(result => {
+														result[field.id] = result[field.id].toLocaleString();
+													});
+												}
+												else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'String') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = result[field.id].toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+													});
+												}
+												else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Currency') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = result[field.id].toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+													});
+												}
+												else if (field.fieldType === 'Boolean' && (!field.leafFormatType || field.leafFormatType === 'Boolean')) {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = result[field.id] === true ? 'True' : 'False';
+													});
+												}
+												else if (field.fieldType === 'Boolean' && field.leafFormatType === 'String') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = result[field.id] === true ? 'Yes' : 'No';
+													});
+												}
+												else if (field.fieldType === 'Boolean' && field.leafFormatType === 'Boolean_Number') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = result[field.id] === true ? 1 : 0;
+													});
+												}
+												else if (field.fieldType === 'Date' && (field.leafFormatType === 'Date')) {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = moment(result[field.id]).format('L');
+													});
+												}
+												else if (field.fieldType === 'Date' && field.leafFormatType === 'Time') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = moment(result[field.id]).format('LT');
+													});
+												}
+												else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = moment(result[field.id]).format('MM/DD/YYYY h:mm A');
+													});
+												}
+												else if (field.fieldType === 'Date' && field.leafFormatType === 'Date_long') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = moment(result[field.id]).format('LL');
+													});
+												}
+												else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime_long') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = moment(result[field.id]).format('LLL');
+													});
+												}
+												else if (field.fieldType === 'Date' && field.leafFormatType === 'Timestamp') {
+													results.filter(a => a[field.id] !== null && a[field.id] !== undefined).forEach(result => {
+														result[field.id] = moment(result[field.id]).toDate().getTime();
+													});
+												}
+											});
+
+											let lines: any = [];
+
+											let tmpHeaders = {};
+
+											report.groups_row.forEach(group => {
+												tmpHeaders[group.id] = group.columnName;
+											});
+
+											report.fields_selected.filter(a => a.show).forEach(header => {
+												tmpHeaders[header.columnName] = header.columnName;
+											});
+
+											let wb = XLSX.utils.book_new();
+
+											results.forEach(result => {
+												let tmp = {};
+												report.groups_row.forEach(group => {
+													if (Array.isArray(result._id[group.id])) {
+														tmp[group.columnName] = result._id[group.id].join(',');
+													}
+													else {
+														if (group.treeItem.fieldType === 'Number') {
+															tmp[group.columnName] = result._id[group.id] ? (typeof(result._id[group.id]) === 'string' ? parseFloat(result._id[group.id].replace(/,/g, '').replace(/\$/g, '')) : result._id[group.id]) : '';
+														}
+														else {
+															tmp[group.columnName] = result._id[group.id] || '';
+														}
+													}
+												});
+												report.fields_selected.filter(a => a.show).forEach(header => {
+													if (Array.isArray(result[header.id])) {
+														tmp[header.columnName] = result[header.id].join(',');
+													}
+													else {
+														if (header.fieldType === 'Number' || header.leafValueType === 'Count') {
+															tmp[header.columnName] = result[header.id] ? (typeof(result[header.id]) === 'string' ? parseFloat(result[header.id].replace(/,/g, '').replace(/\$/g, '')) : result[header.id]) : '';
+														}
+														else {
+															tmp[header.columnName] = result[header.id] || '';
+														}
+													}
+												});
+								
+												lines.push(tmp);
+											});
+
+											let ws = XLSX.utils.json_to_sheet(lines);
+											XLSX.utils.book_append_sheet(wb, ws, 'RB Data');
+									
+											let wbout = XLSX.write(wb, {bookType: 'xlsx', type: 'base64'});
+
+											data['emails'].forEach(email => {
+												this.sendEmail(email,
+												this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name,
+												'',
+												`
+												<b>` + this.serverConfig['CLIENT_NAME'] + ` Automated Report</b><br>
+												<b>Report Name: </b>` + report.report_name + `<br>
+												<b>Prepared By: </b>` + data['user'] + `<br><br>
+												Attached are the results of this automated report.<br><br>
+												ResolveIO<br><br>`,
+												[
+													{
+														filename: report.report_name + '-' + moment().format('MM-DD-YYYY-hh-mm-A') + '.xlsx',
+														content:  wbout,
+														encoding: 'base64'
+													}
+												],
+												this.serverConfig['MAIL_FROM_REPORTS'],
+												''
+												);
+											});
+										}
+										else if (report.type === 'Group') {
+											report.fields_selected.filter(a => a.show).forEach(field => {
+												results.forEach(result => {
+													modifyDataTypeField(report, result, field, 1);
+												});
+											});
+
+											let wb = new Excel.Workbook();
+											let ws = wb.addWorksheet('RB_1', {views: [{showGridLines: false}]});
+											wb.properties.date1904 = false;
+											wb.calcProperties.fullCalcOnLoad = true;
+
+											let currentRow = 1;
+											let row = ws.getRow(currentRow);
+
+											row.getCell(2).font = {
+												name: 'Arial',
+												bold: true,
+												size: 14
+											};
+											row.getCell(4).font = {
+												name: 'Arial',
+												size: 14
+											};
+											row.getCell(2).value = 'Report Name:';
+											row.getCell(4).value = report.report_name;
+
+											currentRow += 1;
+											row = ws.getRow(currentRow);
+
+											row.getCell(2).font = {
+												name: 'Arial',
+												bold: true,
+												size: 14
+											};
+											row.getCell(4).font = {
+												name: 'Arial',
+												size: 14
+											};
+											row.getCell(2).value = 'Run Date:';
+											row.getCell(4).value = moment().format('LLL');
+
+											currentRow += 2;
+
+											let copy = deepCopy(results);
+											let widths = [];
+											copy.forEach(res => {
+												currentRow = tabGroupExcelRecursive(report, ws, currentRow, 1, res);
+												tabGroupExcelWidthRecursive(report, 1, res, widths);
+											});
+
+											for (let i = 1; i < ws.columns.length; i++) {
+												ws.columns[i].width = widths[i - 1];
+											}
+
+											let now = new Date();
+
+											wb.xlsx.writeBuffer().then(buffer => {
+												data['emails'].forEach(email => {
+													this.sendEmail(email,
+													this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name,
+													'',
+													`
+													<b>` + this.serverConfig['CLIENT_NAME'] + ` Automated Report</b><br>
+													<b>Report Name: </b>` + report.report_name + `<br>
+													<b>Prepared By: </b>` + data['user'] + `<br><br>
+													Attached are the results of this automated report.<br><br>
+													Have a great day!<br><br>
+													ResolveIO<br><br>`,
+													[
+														{
+															filename: 'Group_Report_' + report.report_name + '_' + now.getFullYear() + '_' + (now.getMonth() + 1) + '_' + now.getDate() + '.xlsx',
+															content:  buffer
+														}
+													],
+													this.serverConfig['MAIL_FROM_REPORTS'],
+													''
+													);
+												});
+											}).catch(err => console.log('Error writing excel export', err));
+										}
+										else if (report.type === 'Dated') {
+											let lines: any = [];
+								
+											let tmpHeaders = {};
+								
+											report.groups_row.forEach(group => {
+												tmpHeaders[group.id] = group.columnName;
+											});
+								
+											tmpHeaders[''] = '';
+
+											let datedUniqueDates = [];
+											let datedUniqueGroups = [];
+
+											if (report.date_interval === 'Quarterly') {
+												results.forEach(dataPt => {
+													if (dataPt._id.month < 4) {
+														dataPt._id.quarter = 1;
+													}
+													else if (dataPt._id.month < 7) {
+														dataPt._id.quarter = 2;
+													}
+													else if (dataPt._id.month < 10) {
+														dataPt._id.quarter = 3;
+													}
+													else {
+														dataPt._id.quarter = 4;
+													}
+				
+													delete dataPt._id.month;
+												});
+
+												for (let i = results.length - 1; i >= 1; i--) {
+													let dataPt = results[i];
+				
+													if (results.filter(a => JSON.stringify(a._id) === JSON.stringify(dataPt._id)).length > 1) {
+														let tmpData = results.filter(a => JSON.stringify(a._id) === JSON.stringify(dataPt._id))[0];
+														
+														Object.keys(tmpData).filter(a => a !== '_id').forEach(key => {
+				
+															tmpData[key] += dataPt[key];
+														});
+				
+														results.splice(i, 1);
+													}
+												}
+											}
+
+											let tmpResults = deepCopy(results);
+											tmpResults.forEach(result => {
+												delete result._id.day;
+												delete result._id.week;
+												delete result._id.month;
+												delete result._id.quarter;
+												delete result._id.year;
+
+												let tmp = {};
+
+												Object.keys(result._id).forEach(key => {
+													tmp[key] = result._id[key];
+												});
+
+												if (!datedUniqueGroups.filter(a => JSON.stringify(a) === JSON.stringify(tmp)).length) {
+													datedUniqueGroups.push(tmp);
+												}
+											});
+
+											tmpResults = deepCopy(results);
+
+											tmpResults.forEach(result => {
+												Object.keys(result._id).filter(a => a !== 'second' && a !== 'hour' && a !== 'minute' && a !== 'day' && a !== 'week' && a !== 'month' && a !== 'quarter' && a !== 'year').forEach(key => {
+													delete result._id[key];
+												});
+
+												let tmp = {};
+
+												Object.keys(result._id).forEach(key => {
+													tmp[key] = result._id[key];
+												});
+
+												if (!datedUniqueDates.filter(a => JSON.stringify(a) === JSON.stringify(tmp)).length) {
+													datedUniqueDates.push(tmp);
+												}
+											});
+											
+											datedUniqueDates.forEach(result => {
+												if (!result.year) {
+													result.dateString = 'No Date';
+												}
+												else {
+													if (report.date_interval === 'Seconds') {
+														result.date = new Date(result.year, result.month - 1, result.day, result.hour, result.minute, result.second, 0);
+														result.dateString = moment(result.date).format('MMM DD YYYY HH:mm:ss');
+													}
+													else if (report.date_interval === 'Minutes') {
+														result.date = new Date(result.year, result.month - 1, result.day, result.hour, result.minute, 0, 0);
+														result.dateString = moment(result.date).format('MMM DD YYYY HH:mm');
+													}
+													else if (report.date_interval === 'Hours') {
+														result.date = new Date(result.year, result.month - 1, result.day, result.hour, 0, 0, 0);
+														result.dateString = moment(result.date).format('MMM DD YYYY HH');
+													}
+													else if (report.date_interval === 'Daily') {
+														result.date = new Date(result.year, result.month - 1, result.day, 0, 0, 0, 0);
+														result.dateString = moment(result.date).format('MMM DD YYYY');
+													}
+													else if (report.date_interval === 'Weekly') {
+														result.date = moment().day('Monday').isoWeekYear(result.year).isoWeek(result.week).toDate();
+														result.dateLast = moment().day('Sunday').isoWeekYear(result.year).isoWeek(result.week).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 = new Date(result.year, result.month - 1, 1, 0, 0, 0, 0);
+														result.dateString = moment(result.date).format('MMM YYYY');
+													}
+													else if (report.date_interval === 'Quarterly') {
+														result.date = moment().quarter(result.quarter).year(result.year).toDate();
+														result.dateString = 'Q' + result.quarter + ' ' + result.year;
+													}
+													else if (report.date_interval === 'Yearly') {
+														result.date = new Date(result.year);
+														result.dateString = result.year.toString();
+													}
+												}
+											});
+
+											datedUniqueDates = datedUniqueDates.filter(a => !a.date).concat(datedUniqueDates.filter(a => a.date).sort((a, b) => a.date.getTime() - b.date.getTime()));
+
+											let reportTotalGroups = [];
+											let reportTotalDates = [];
+											let datedData = [];
+
+											datedUniqueDates.forEach(date => {
+												let tmpData = [];
+												let tmpTotalDated = {};
+												let tmpTotalCnt = {};
+												let tmpTotalType = {};
+												
+												datedUniqueGroups.forEach(group => {
+													let result = results.filter(a => {
+														let res = true;
+
+														Object.keys(date).filter(a => a !== 'date' && a !== 'dateLast' && a !== 'dateString').forEach(key => {
+															if (a._id[key] !== date[key]) {
+																res = false;
+															}
+														});
+
+														Object.keys(group).forEach(key => {
+															if (a._id[key] !== group[key]) {
+																res = false;
+															}
+														});
+
+														return res;
+													})[0];
+
+													if (result) {
+														tmpData.push(result);
+
+														Object.keys(result._id).filter(a => a).forEach(key => {
+															if (report.fields_total.filter(a => a.fields.includes(key)).length) {
+																if (!tmpTotalDated[key]) {
+																	tmpTotalDated[key] = result._id[key];
+																}
+																else {
+																	tmpTotalDated[key] += result._id[key];
+																}
+																
+																if (!tmpTotalCnt[key]) {
+																	tmpTotalCnt[key] = 1;
+																}
+																else {
+																	tmpTotalCnt[key] += 1;
+																}
+
+																tmpTotalType[key] = report.fields_total.filter(a => a.fields.includes(key))[0].type;
+															}
+														});
+
+														Object.keys(result).filter(a => a && a !== '_id').forEach(key => {
+															if (report.fields_total.filter(a => a.fields.includes(key)).length) {
+																if (!tmpTotalDated[key]) {
+																	tmpTotalDated[key] = result[key];
+																}
+																else {
+																	tmpTotalDated[key] += result[key];
+																}
+																
+																if (!tmpTotalCnt[key]) {
+																	tmpTotalCnt[key] = 1;
+																}
+																else {
+																	tmpTotalCnt[key] += 1;
+																}
+
+																tmpTotalType[key] = report.fields_total.filter(a => a.fields.includes(key))[0].type;
+															}
+														});
+													}
+													else {
+														tmpData.push(null);
+													}
+												});
+
+												Object.keys(tmpTotalType).forEach(totalKey => {
+													if (tmpTotalType[totalKey] === 'avg') {
+														tmpTotalDated[totalKey] = tmpTotalDated[totalKey] / tmpTotalCnt[totalKey];
+													}
+
+													tmpTotalDated[totalKey] = Math.round(tmpTotalDated[totalKey] * 100) / 100;
+												});
+
+												reportTotalDates.push(tmpTotalDated);
+												datedData.push(tmpData);
+											});
+
+											datedUniqueGroups.forEach(group => {
+												let tmpTotalGroup = {};
+												let filteredData = results.filter(a => {
+													let res = (!Object.keys(group).length || group._id === null) ? false : true;
+													
+													Object.keys(group).filter(a => a !== 'date' && a !== 'dateLast' && a !== 'dateString' && a !== 'second' && a !== 'minute' && a !== 'hour' && a !== 'day' && a !== 'week' && a !== 'month' && a !== 'quarter' && a !== 'year').forEach(key => {
+														if (a._id[key] !== group[key]) {
+															res = false;
+														}
+													});
+					
+													return res;
+												});
+
+												report.fields_total.forEach(total => {
+													total.fields.forEach(field => {
+														if (filteredData.length) {
+															tmpTotalGroup[field] = filteredData.filter(a => a && a[field]).map(a => a[field]).reduce((a, b) => a + b, 0);
+
+															if (total.type === 'avg') {
+																tmpTotalGroup[field] = Math.round(tmpTotalGroup[field] / filteredData.length * 100) / 100;
+															}
+														}
+														else {
+															tmpTotalGroup[field] = 0;
+														}
+													});
+												});
+
+												reportTotalGroups.push(tmpTotalGroup);
+											});
+								
+											datedUniqueDates.forEach(date => {
+												tmpHeaders[date.dateString] = date.dateString;
+											});
+
+											report.fields_total.forEach(total => {
+												tmpHeaders['Totals - ' + total.type.toUpperCase()] = 'Totals - ' + toTitleCase(total.type);
+											});
+								
+											lines.push(tmpHeaders);
+
+											let selectedFields = deepCopy(report.fields_selected);
+											//add custom
+											report.fields_custom.forEach(customField => {
+												selectedFields.push({
+													collection_name : '',
+													columnName : customField.columnName,
+													fieldName : customField.selFieldId,
+													fieldType : 'Number',
+													fieldTypeName : 'Number',
+													distinctFieldValues : [],
+													fieldPath : customField.selFieldId,
+													fieldPathName :  'Custom Field',
+													lookup_collection : '',
+													lookup_local_key : '',
+													lookup_foreign_key : '',
+													lookup_as : '',
+													text : '',
+													value : '',
+													isLeaf : true,
+													isActive : true,
+													isSelected : true,
+													depth : 0,
+													leafValueType : customField.leafValueType,
+													leafValueTypes : [],
+													leafFormatType : 'Number',
+													leafFormatTypes : [],
+													id : customField.selFieldId,
+													show: true
+												});
+											});
+								
+											for (let i = 0; i < datedUniqueGroups.length; i++) {
+												let group = datedUniqueGroups[i];
+								
+												const fieldsSelectedArr = selectedFields.filter(a => a.show);
+												for (let j = 0; j < fieldsSelectedArr.length; j++) {
+													let field = fieldsSelectedArr[j];
+								
+													let tmp = {};
+								
+													for (let k = 0; k <= report.groups_row.length - 1; k++) {
+														let groupRow = report.groups_row[k];
+								
+														if (j === 0) {
+															tmp[group[groupRow.id]] = group[groupRow.id];
+														}	
+														else {
+															tmp[group[groupRow.id]] = '';
+														}					
+													}
+								
+													tmp[field.columnName] = field.columnName;
+								
+													for (let k = 0; k <= datedData.length - 1; k++) {
+														let result = datedData[k];
+								
+														if (result[i]) {
+															if (allLeaves.filter(a => a.id === field.id)[0] && allLeaves.filter(a => a.id === field.id)[0].fieldType === 'Number') {
+																tmp[i + ' ' + j + ' ' + k] = result[i][field.id] ? (typeof(result[i][field.id]) === 'string' ? parseInt(result[i][field.id].replace(/,/g, '')) : result[i][field.id]) : '';
+															}
+															else {
+																tmp[i + ' ' + j + ' ' + k] = result[i][field.id] ? (typeof(result[i][field.id]) === 'string' ? result[i][field.id].replace(/,/g, '') : result[i][field.id]) : '';
+															}
+														}		
+														else {
+															tmp[i + ' ' + j + ' ' + k] = '';
+														}
+													}
+								
+													for (let k = 0; k <= report.fields_total.length - 1; k++) {
+														let total = report.fields_total[k];
+								
+														if (total.fields.includes(field.id)) {
+															tmp['total' + i + ' ' + j + ' ' + k] = reportTotalGroups[i][field.id] ? (typeof(reportTotalGroups[i][field.id]) === 'string' ? parseInt(reportTotalGroups[i][field.id].replace(/,/g, '')) : reportTotalGroups[i][field.id]) : '';
+														}		
+														else {
+															tmp['total' + i + ' ' + j + ' ' + k] = '';
+														}
+													}
+								
+													lines.push(tmp);
+												}
+											}
+								
+											if (reportTotals) {
+												for (let i = 0; i < report.fields_total.length; i++) {
+													let total = report.fields_total[i];
+													let tmp = {};
+
+													tmp[total.type] = toTitleCase(total.type) + ' Totals';
+
+													for (let j = 0; j < report.groups_row.length - 1; j++) {
+														tmp['total_gr_j'] = '';
+													}
+								
+													tmp['Total - Fields'] = '';
+								
+													for (let j = 0; j < datedData.length; j++) {
+														tmp['Total - Dated ' + j] = '';
+													}
+								
+													for (let j = 0; j <= report.fields_selected.filter(a => a.show).length - 1; j++) {
+														let field = report.fields_selected.filter(a => a.show)[j];
+								
+														if (total.fields.includes(field.id)) {
+															tmp['totalreportTotals' + j] = reportTotals[total.id + '_' + field.id];
+														}
+														else {
+															tmp['totalreportTotals' + j] = '';
+														}
+													}
+								
+													lines.push(tmp);
+												}
+											}
+
+											let newCSV = '';
+
+											lines.forEach((row, index) => {
+												Object.keys(row).forEach((key, keyIndex) => {
+													if (row[key] && typeof(row[key]) === 'string') {
+														row[key] = row[key].replace(new RegExp(/,/g), '');
+													}
+
+													newCSV += row[key];
+
+													if (keyIndex < Object.keys(row).length - 1) {
+														newCSV += ',';
+													}
+												});
+
+												if (index < lines.length - 1) {
+													newCSV += '\r\n';
+												}
+											});
+
+											data['emails'].forEach(email => {
+												this.sendEmail(email,
+												this.serverConfig['CLIENT_NAME'] + ' Scheduled Report - ' + report.report_name,
+												'',
+												`
+												<b>` + this.serverConfig['CLIENT_NAME'] + ` Automated Report</b><br>
+												<b>Report Name: </b>` + report.report_name + `<br>
+												<b>Prepared By: </b>` + data['user'] + `<br><br>
+												Attached are the results of this automated report.<br><br>
+												Have a great day!<br><br>
+												ResolveIO<br><br>`,
+												[
+													{
+														filename: report.report_name + '-' + moment().format('MM-DD-YYYY-hh-mm-A') + '.csv',
+														content:  newCSV
+													}
+												],
+												this.serverConfig['MAIL_FROM_REPORTS'],
+												''
+												);
+											});
+
+											resolve(true);
+										}
+									}
+									else {										
+										this.callMethodInternal('insertErrorLog', 'Report Builder Cron Job - Report Builder Get Results', [
+											err
+										]);
+										
+										reject(err);
+									}
+								});
+							}
+						});
+					}
+				});
+			}
+		}
+	});
+}
+
+function getTreeLeaves(items, resArray, allowLookups = false) {
+	items.forEach(item => {
+		if (item.isLeaf) {
+			resArray.push(item);
+		}
+		else {
+			if (!item.lookup_collection || allowLookups) {
+				getTreeLeaves(item.children, resArray, allowLookups);
+			}
+		}
+	});
+}
+
+function modifyDataTypeField(report, result, field, index) {
+	if (index < report.groups_row.length) {
+		result = result['gr_' + (index + 1)];
+		result.forEach((tDataRes, tIndex) => {
+			modifyDataTypeField(report, tDataRes, field, index + 1)
+		});
+	}
+	else {
+		if (Array.isArray(result[field.id])) {
+			result[field.id].forEach((arr, arrIndex) => {
+				if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Number') {
+					result[field.id].splice(arrIndex, 1, arr.toLocaleString());
+				}
+				else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'String') {
+					result[field.id].splice(arrIndex, 1, arr.toString());
+				}
+				else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Currency') {
+					result[field.id].splice(arrIndex, 1, arr.toLocaleString('en-US', { style: 'currency', currency: 'USD' }));
+				}
+				else if (field.fieldType === 'Boolean' && (!field.leafFormatType || field.leafFormatType === 'Boolean')) {
+					result[field.id].splice(arrIndex, 1, arr === true ? 'True' : 'False');
+				}
+				else if (field.fieldType === 'Boolean' && field.leafFormatType === 'String') {
+					result[field.id].splice(arrIndex, 1, arr === true ? 'Yes' : 'No');
+				}
+				else if (field.fieldType === 'Boolean' && field.leafFormatType === 'Boolean_Number') {
+					result[field.id].splice(arrIndex, 1, arr === true ? 1 : 0);
+				}
+				else if (field.fieldType === 'Date' && (field.leafFormatType === 'Date')) {
+					result[field.id].splice(arrIndex, 1, moment(arr).format('L'));
+				}
+				else if (field.fieldType === 'Date' && field.leafFormatType === 'Time') {
+					result[field.id].splice(arrIndex, 1, moment(arr).format('LT'));
+				}
+				else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime') {
+					result[field.id].splice(arrIndex, 1, moment(arr).format('MM/DD/YYYY h:mm A'));
+				}
+				else if (field.fieldType === 'Date' && field.leafFormatType === 'Date_long') {
+					result[field.id].splice(arrIndex, 1, moment(arr).format('LL'));
+				}
+				else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime_long') {
+					result[field.id].splice(arrIndex, 1, moment(arr).format('LLL'));
+				}
+				else if (field.fieldType === 'Date' && field.leafFormatType === 'Timestamp') {
+					result[field.id].splice(arrIndex, 1, moment(arr).toDate().getTime());
+				}
+			});
+		}
+		else {
+			if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Number') {
+				result[field.id] = result[field.id].toLocaleString();
+			}
+			else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'String') {
+				result[field.id] = result[field.id].toString();
+			}
+			else if ((field.fieldType === 'Number' || field.leafValueType === 'Count') && field.leafFormatType === 'Currency') {
+				result[field.id] = result[field.id].toLocaleString('en-US', { style: 'currency', currency: 'USD' });
+			}
+			else if (field.fieldType === 'Boolean' && (!field.leafFormatType || field.leafFormatType === 'Boolean')) {
+				result[field.id] = result[field.id] === true ? 'True' : 'False';
+			}
+			else if (field.fieldType === 'Boolean' && field.leafFormatType === 'String') {
+				result[field.id] = result[field.id] === true ? 'Yes' : 'No';
+			}
+			else if (field.fieldType === 'Boolean' && field.leafFormatType === 'Boolean_Number') {
+				result[field.id] = result[field.id] === true ? 1 : 0;
+			}
+			else if (field.fieldType === 'Date' && (field.leafFormatType === 'Date')) {
+				result[field.id] = moment(result[field.id]).format('L');
+			}
+			else if (field.fieldType === 'Date' && field.leafFormatType === 'Time') {
+				result[field.id] = moment(result[field.id]).format('LT');
+			}
+			else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime') {
+				result[field.id] = moment(result[field.id]).format('MM/DD/YYYY h:mm A');
+			}
+			else if (field.fieldType === 'Date' && field.leafFormatType === 'Date_long') {
+				result[field.id] = moment(result[field.id]).format('LL');
+			}
+			else if (field.fieldType === 'Date' && field.leafFormatType === 'DateTime_long') {
+				result[field.id] = moment(result[field.id]).format('LLL');
+			}
+			else if (field.fieldType === 'Date' && field.leafFormatType === 'Timestamp') {
+				result[field.id] = moment(result[field.id]).toDate().getTime();
+			}
+		}
+	}
+}
+
+function tabGroupExcelRecursive(report, ws: Excel.Worksheet, currentRow, level, result) {
+	let row = ws.getRow(currentRow);
+
+	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
+		};
+
+		row.getCell(2).value = report.groups_row[level - 1].columnName + ': ' + result._id['gr_' + level];
+		ws.mergeCells(row.getCell(2).$col$row + ':' + row.getCell(report.fields_selected.filter(a => a.show).length + 1).$col$row);
+		
+		row.getCell(2).border = {
+			top: {style:'thick'},
+			left: {style:'thick'},
+			right: {style: 'thick'}
+		};
+
+		if (report.fields_total.length) {
+			report.fields_total.forEach(total => {
+				currentRow += 1;
+				row = ws.getRow(currentRow);
+
+				report.fields_selected.filter(a => a.show).forEach((field, fieldIndex) => {
+					if (total.fields.includes(field.id)) {
+						row.getCell(fieldIndex + 2).value = field.columnName;
+
+						row.getCell(fieldIndex + 2).font = {
+							name: 'Arial',
+							bold: true,
+							size: 10
+						};
+					}
+
+					if (field.leafFormatType === 'Currency') {
+						row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+					}
+					else if (field.leafFormatType === 'Number') {
+						row.getCell(fieldIndex + 2).numFmt = '#,##0';
+					}
+
+					if (fieldIndex === 0) {
+						row.getCell(fieldIndex + 2).border = {
+							left: {style:'thick'}
+						};
+					}
+					else if (fieldIndex === report.fields_selected.filter(a => a.show).length - 1) {
+						row.getCell(fieldIndex + 2).border = {
+							right: {style:'thick'}
+						};
+					}
+				});
+			});
+		}
+		
+		// Totals
+		report.fields_total.forEach(total => {
+			currentRow += 1;
+			row = ws.getRow(currentRow);
+
+			report.fields_selected.filter(a => a.show).forEach((field, fieldIndex) => {
+				if (total.fields.includes(field.id)) {
+					row.getCell(fieldIndex + 2).value = result[total.id + '_' + field.id];
+
+					row.getCell(fieldIndex + 2).font = {
+						name: 'Arial',
+						bold: true,
+						size: 10
+					};
+
+					if (field.leafFormatType === 'Currency') {
+						row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+					}
+					else if (field.leafFormatType === 'Number') {
+						row.getCell(fieldIndex + 2).numFmt = '#,##0';
+					}
+				}
+
+				if (fieldIndex === 0) {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						left: {style:'thick'},
+						bottom: {style:'thick'}
+					};
+				}
+				else if (fieldIndex === report.fields_selected.filter(a => a.show).length - 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;
+
+		result = result['gr_' + (level + 1)];
+		result.forEach((tDataRes, tIndex) => {
+			currentRow = tabGroupExcelRecursive(report, ws, currentRow, level + 1, tDataRes);
+		});
+	}
+	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
+		};
+
+		row.getCell(2).value = report.groups_row[level - 1].columnName + ': ' + result._id['gr_' + level];
+		ws.mergeCells(row.getCell(2).$col$row + ':' + row.getCell(report.fields_selected.filter(a => a.show).length + 1).$col$row);
+
+		row.getCell(2).border = {
+			top: {style:'thick'},
+			left: {style:'thick'},
+			right: {style: 'thick'}
+		};
+
+		currentRow += 1;
+		row = ws.getRow(currentRow);
+		// Headers
+		report.fields_selected.filter(a => a.show).forEach((field, fieldIndex) => {
+			row.getCell(fieldIndex + 2).value = field.columnName;
+			row.getCell(fieldIndex + 2).font = {
+				name: 'Arial',
+				bold: true,
+				size: 10
+			};
+
+			if (field.leafFormatType === 'Currency') {
+				row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+			}
+			else if (field.leafFormatType === 'Number') {
+				row.getCell(fieldIndex + 2).numFmt = '#,##0';
+			}
+
+			if (fieldIndex === 0) {
+				row.getCell(fieldIndex + 2).border = {
+					left: {style:'thick'}
+				};
+			}
+			else if (fieldIndex === report.fields_selected.filter(a => a.show).length - 1) {
+				row.getCell(fieldIndex + 2).border = {
+					right: {style:'thick'}
+				};
+			}
+		});
+
+		// Data
+		result['f_0'].forEach((res, resIndex) => {
+			currentRow += 1;
+			row = ws.getRow(currentRow);
+
+			report.fields_selected.filter(a => a.show).forEach((field, fieldIndex) => {
+				if (field.fieldType === 'Number' && typeof(result[field.id][resIndex] === 'string') && result[field.id][resIndex]) {
+					row.getCell(fieldIndex + 2).value = parseFloat(result[field.id][resIndex].replace(new RegExp(/\,/g), '').replace(new RegExp(/\$/g), ''));
+				}
+				else {
+					row.getCell(fieldIndex + 2).value = result[field.id][resIndex];
+				}
+
+				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 === report.fields_selected.filter(a => a.show).length - 1) {
+					row.getCell(fieldIndex + 2).border = {
+						right: {style:'thick'}
+					};
+				}
+			});
+		});
+		
+		// Totals
+		report.fields_total.forEach(total => {
+			currentRow += 1;
+			row = ws.getRow(currentRow);
+
+			report.fields_selected.filter(a => a.show).forEach((field, fieldIndex) => {
+				if (total.fields.includes(field.id)) {
+					row.getCell(fieldIndex + 2).value = result[total.id + '_' + field.id];
+
+					row.getCell(fieldIndex + 2).font = {
+						name: 'Arial',
+						bold: true,
+						size: 10
+					};
+
+					if (field.leafFormatType === 'Currency') {
+						row.getCell(fieldIndex + 2).numFmt = '"$"#,##0.00';
+					}
+					else if (field.leafFormatType === 'Number') {
+						row.getCell(fieldIndex + 2).numFmt = '#,##0';
+					}
+				}
+
+				if (fieldIndex === 0) {
+					row.getCell(fieldIndex + 2).border = {
+						top: {style:'thin'},
+						left: {style:'thick'},
+						bottom: {style:'thick'}
+					};
+				}
+				else if (fieldIndex === report.fields_selected.filter(a => a.show).length - 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) {
+	if (level < report.groups_row.length) {
+		result = result['gr_' + (level + 1)];
+		result.forEach((tDataRes, tIndex) => {
+			cols = tabGroupExcelWidthRecursive(report, level + 1, tDataRes, cols);
+		});
+	}
+	else {
+		report.fields_selected.filter(a => a.show).forEach((field, fieldIndex) => {
+			if (Array.isArray(result[field.id])) {
+				result[field.id].forEach(res => {
+					let length = 10;
+
+					if (res) {
+						length = res.length + 3;
+					}
+
+					if (!cols[fieldIndex]) {
+						cols[fieldIndex] = Math.max(10, field.columnName.length);
+					}
+
+					if (length > cols[fieldIndex]) {
+						cols[fieldIndex] = length;
+					}
+				});
+			}
+			else {
+				let res = result[field.id];
+
+				if (res) {
+					length = res.length + 3;
+				}
+
+				if (!cols[fieldIndex]) {
+					cols[fieldIndex] = Math.max(10, field.columnName.length);
+				}
+
+				if (length > cols[fieldIndex]) {
+					cols[fieldIndex] = length;
+				}
+			}
+		});
+	}
+
+	return cols;
+}