@resolveio/server-lib 22.3.125 → 22.3.126

package/src/methods/pdf.ts

@@ -0,0 +1,1236 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import axios from 'axios';
+import { ParseSpeeds, PDFDocument } from 'pdf-lib';
+import * as puppeteer from 'puppeteer';
+import SimpleSchema from 'simpl-schema';
+import { Flags } from '../collections/flag.collection';
+import { MethodManager } from '../managers/method.manager';
+import { objectIdHexString } from '../util/common';
+
+const PUPPETEER_ARGS = [
+	'--disable-dev-shm-usage',
+	'--no-sandbox',
+	'--disable-setuid-sandbox',
+	'--disable-accelerated-2d-canvas',
+	'--disable-gpu',
+	'--allow-file-access-from-files',
+	'--enable-local-file-accesses',
+	'--font-render-hinting=none',
+	'--disable-breakpad',
+	'--no-zygote'
+];
+
+const LOW_RESOURCE_PUPPETEER_ARGS = [
+	'--single-process',
+	'--renderer-process-limit=1',
+	'--disable-extensions',
+	'--disable-features=AudioServiceOutOfProcess'
+];
+
+let cachedExecutablePath: string = null;
+let cachedTmpExecutablePath: string = null;
+
+function getBrowserConnectUrl() {
+	let browserUrl = process.env.PUPPETEER_BROWSER_URL || process.env.PDF_PUPPETEER_BROWSER_URL || process.env.BROWSER_WS_URL;
+
+	if (!browserUrl || typeof browserUrl !== 'string') {
+		return null;
+	}
+
+	return browserUrl.trim() || null;
+}
+
+function envMs(name: string, fallback: number) {
+	let raw = process.env[name];
+	if (!raw) {
+		return fallback;
+	}
+
+	let parsed = parseInt(raw, 10);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		return fallback;
+	}
+
+	return parsed;
+}
+
+const PDF_LAUNCH_TIMEOUT_MS = envMs('PDF_LAUNCH_TIMEOUT_MS', 60000);
+const PDF_CONTENT_TIMEOUT_MS = envMs('PDF_CONTENT_TIMEOUT_MS', 60000);
+const PDF_FONTS_TIMEOUT_MS = envMs('PDF_FONTS_TIMEOUT_MS', 30000);
+const PDF_IMAGES_TIMEOUT_MS = envMs('PDF_IMAGES_TIMEOUT_MS', 15000);
+const PDF_RENDER_TIMEOUT_MS = envMs('PDF_RENDER_TIMEOUT_MS', 120000);
+const PDF_PROTOCOL_TIMEOUT_MS = envMs('PDF_PROTOCOL_TIMEOUT_MS', 120000);
+const PDF_OVERALL_TIMEOUT_MS = envMs('PDF_OVERALL_TIMEOUT_MS', 240000);
+
+class PdfTimeoutError extends Error {
+	step: string;
+	timeoutMs: number;
+
+	constructor(step: string, timeoutMs: number) {
+		super(`PDF step timed out after ${timeoutMs}ms: ${step}`);
+		this.name = 'PdfTimeoutError';
+		this.step = step;
+		this.timeoutMs = timeoutMs;
+	}
+}
+
+function withTimeout<T>(promise: Promise<T>, timeoutMs: number, step: string): Promise<T> {
+	if (!timeoutMs || timeoutMs <= 0) {
+		return promise;
+	}
+
+	let timeoutHandle: NodeJS.Timeout = null;
+
+	// eslint-disable-next-line no-restricted-syntax
+	return new Promise<T>((resolve, reject) => {
+		timeoutHandle = setTimeout(() => {
+			reject(new PdfTimeoutError(step, timeoutMs));
+		}, timeoutMs);
+
+		// eslint-disable-next-line no-restricted-syntax, promise/prefer-await-to-then
+		promise.then(resolve, reject).finally(() => {
+			if (timeoutHandle) {
+				clearTimeout(timeoutHandle);
+			}
+		});
+	});
+}
+
+function getEnvExecutablePath() {
+	let envExecutablePath = process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_EXECUTABLE_PATH || process.env.CHROME_PATH;
+
+	if (envExecutablePath && fs.existsSync(envExecutablePath)) {
+		return envExecutablePath;
+	}
+
+	return null;
+}
+
+function shouldRetryBrowserLaunch(err: any) {
+	if (!err) {
+		return false;
+	}
+
+	let message = err.message || '';
+	let stderr = err.stderr ? err.stderr.toString() : '';
+
+	return message.includes('chrome_crashpad_handler') || message.includes('Operation not permitted') || message.includes('Resource temporarily unavailable') || stderr.includes('pthread_create') || stderr.includes('Resource temporarily unavailable') || stderr.includes('Failed to connect to the bus');
+}
+
+function prepareExecutableFallback(executablePath?: string) {
+	try {
+		let currentExecutablePath = executablePath || cachedExecutablePath || puppeteer.executablePath();
+
+		if (!currentExecutablePath) {
+			return null;
+		}
+
+		// Avoid copying if we're already running from a tmp dir.
+		if (currentExecutablePath.startsWith(os.tmpdir())) {
+			return null;
+		}
+
+		// Retry from a tmp location when the packaged Chromium cannot be executed (e.g. noexec home dirs).
+		let chromiumDir = path.dirname(currentExecutablePath);
+		let tmpRoot = path.join(os.tmpdir(), 'puppeteer-chromium');
+		let tmpChromiumDir = path.join(tmpRoot, path.basename(chromiumDir));
+		let tmpExecutablePath = path.join(tmpChromiumDir, path.basename(currentExecutablePath));
+
+		if (!fs.existsSync(tmpExecutablePath)) {
+			fs.mkdirSync(tmpChromiumDir, { recursive: true });
+			fs.cpSync(chromiumDir, tmpChromiumDir, { recursive: true, force: true });
+		}
+
+		cachedTmpExecutablePath = tmpExecutablePath;
+		return tmpExecutablePath;
+	}
+	catch (errCopy) {
+		console.error(new Date(), 'Failed to prepare Chromium fallback', errCopy);
+		return null;
+	}
+}
+
+function sanitizeLaunchEnv(env?: NodeJS.ProcessEnv) {
+	let launchEnv: NodeJS.ProcessEnv = { ...process.env, ...env };
+
+	if (launchEnv.DBUS_SESSION_BUS_ADDRESS && !launchEnv.DBUS_SESSION_BUS_ADDRESS.startsWith('unix:') && !launchEnv.DBUS_SESSION_BUS_ADDRESS.startsWith('tcp:')) {
+		delete launchEnv.DBUS_SESSION_BUS_ADDRESS;
+	}
+
+	return launchEnv;
+}
+
+function applyLowResourceLaunchTweaks(options: puppeteer.LaunchOptions): puppeteer.LaunchOptions {
+	let mergedArgs = [...(options.args || [])];
+
+	LOW_RESOURCE_PUPPETEER_ARGS.forEach((arg) => {
+		if (!mergedArgs.includes(arg)) {
+			mergedArgs.push(arg);
+		}
+	});
+
+	return {
+		...options,
+		args: mergedArgs,
+		ignoreDefaultArgs: undefined,
+		env: sanitizeLaunchEnv(options.env)
+	};
+}
+
+async function safeCloseBrowser(browser: puppeteer.Browser) {
+	if (!browser) {
+		return;
+	}
+
+	let proc: any = null;
+	let isConnectedBrowser = false;
+
+	try {
+		proc = typeof browser.process === 'function' ? browser.process() : null;
+		isConnectedBrowser = !proc && browser.connected;
+	}
+	catch {
+		proc = null;
+		isConnectedBrowser = false;
+	}
+
+	try {
+		if (isConnectedBrowser) {
+			await Promise.resolve(browser.disconnect());
+		}
+		else {
+			await withTimeout(browser.close(), 5000, 'browser.close');
+		}
+	}
+	catch (errClose) {
+		console.error(new Date(), 'Puppeteer close failed, forcing kill', errClose && errClose.message ? errClose.message : errClose);
+	}
+	finally {
+		let needsKill = proc && proc.exitCode === null && proc.signalCode === null;
+
+		if (needsKill) {
+			try {
+				proc.kill('SIGKILL');
+			}
+			catch (errKill: any) {
+				if (!errKill || errKill.code !== 'ESRCH') {
+					console.error(new Date(), 'Failed to kill Puppeteer process', errKill);
+				}
+			}
+		}
+	}
+}
+
+async function launchPDFBrowser(headless: boolean, devtools: boolean) {
+	let browserUrl = getBrowserConnectUrl();
+
+	if (browserUrl) {
+		return await puppeteer.connect({
+			browserURL: browserUrl,
+			protocolTimeout: PDF_PROTOCOL_TIMEOUT_MS,
+			defaultViewport: null
+		});
+	}
+
+	let envExecutablePath = getEnvExecutablePath();
+
+	if (!cachedExecutablePath) {
+		cachedExecutablePath = envExecutablePath || puppeteer.executablePath();
+	}
+
+	let launchOptions: puppeteer.LaunchOptions = {
+		headless,
+		devtools,
+		args: [...PUPPETEER_ARGS],
+		ignoreDefaultArgs: ['--disable-extensions'],
+		env: sanitizeLaunchEnv(),
+		timeout: PDF_LAUNCH_TIMEOUT_MS,
+		protocolTimeout: PDF_PROTOCOL_TIMEOUT_MS
+	};
+
+	if (cachedExecutablePath) {
+		launchOptions.executablePath = cachedExecutablePath;
+	}
+
+	try {
+		return await puppeteer.launch(launchOptions);
+	}
+	catch (errLaunch) {
+		if (!shouldRetryBrowserLaunch(errLaunch)) {
+			throw errLaunch;
+		}
+
+		let fallbackExecutablePath = cachedTmpExecutablePath || prepareExecutableFallback(launchOptions.executablePath);
+
+		let retryOptions: puppeteer.LaunchOptions = applyLowResourceLaunchTweaks({
+			...launchOptions,
+			executablePath: fallbackExecutablePath || launchOptions.executablePath
+		});
+
+		if (fallbackExecutablePath) {
+			cachedExecutablePath = fallbackExecutablePath;
+		}
+
+		console.warn(new Date(), 'Retrying Puppeteer launch with low-resource args');
+
+		return await puppeteer.launch(retryOptions);
+	}
+}
+
+export function loadPDFMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		generatePDF: {
+			bypassSession: true,
+			check: new SimpleSchema({
+				html: {
+					type: String
+				},
+				fileName: {
+					type: String
+				},
+				orientation: {
+					type: String,
+					optional: true
+				},
+				fontSize: {
+					type: String,
+					optional: true
+				},
+				upload: {
+					type: Boolean,
+					optional: true
+				},
+				uploadFileOrder: {
+					type: Number,
+					optional: true
+				},
+				uploadFileType: {
+					type: String,
+					optional: true
+				}
+			}),
+				function: async function(html, fileName, orientation = 'portrait', fontSize = '12px', upload = false, uploadFileOrder = -1, uploadFileType = '') {
+					// console.log(new Date(), 'GENERATE PDF CALL', fileName, orientation, fontSize, upload);
+
+					let enableDebugFlag = await Flags.findOne({type: 'Enable Debug PDF'});
+
+					let enableDebug = !!(enableDebugFlag && enableDebugFlag.value);
+
+					const maxAttempts = 2;
+					let lastError: any = null;
+
+					for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+						let browser: puppeteer.Browser = null;
+						let page: puppeteer.Page = null;
+						let overallTimedOut = false;
+						let overallTimeoutHandle: NodeJS.Timeout = null;
+
+						try {
+							browser = await withTimeout(launchPDFBrowser(!enableDebug, enableDebug), PDF_LAUNCH_TIMEOUT_MS, 'launchPDFBrowser');
+
+							overallTimeoutHandle = setTimeout(() => {
+								overallTimedOut = true;
+								console.error(new Date(), 'generatePDF overall timeout hit', { fileName, attempt });
+								// eslint-disable-next-line no-restricted-syntax, promise/prefer-await-to-then
+								safeCloseBrowser(browser).catch(() => {});
+							}, PDF_OVERALL_TIMEOUT_MS);
+
+							page = await browser.newPage();         // create new tab
+							page.setDefaultTimeout(PDF_CONTENT_TIMEOUT_MS);
+
+							let pathToFont = '';
+
+							if (fs.existsSync(path.join(__dirname, ('../private/fonts/dejavuserif.woff')))) {
+								pathToFont = path.join(__dirname, ('../private/fonts/'));
+							}
+						else {
+							if (fs.existsSync(path.join(this.clientDir, ('./private/fonts/dejavuserif.woff')))) {
+								pathToFont = path.join(this.clientDir, ('./private/fonts/'));
+							}
+							else {
+								pathToFont = '/usr/share/fonts/dejavu/';
+							}
+						}
+
+						let dejavuserif_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif.woff').buffer).toString('base64');
+						let dejavuserifBold_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif-bold.woff').buffer).toString('base64');
+						let dejavuserifItalic_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif-italic.woff').buffer).toString('base64');
+						let dejavuserifBoldItalic_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif-bolditalic.woff').buffer).toString('base64');
+
+						let content = `
+							<head>
+								<style type="text/css">
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: normal;
+										font-weight: normal;
+										src: url("` + dejavuserif_woff + `") format('woff');
+									}
+
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: normal;
+										font-weight: bold;
+										src: url("` + dejavuserifBold_woff + `") format('woff');
+									}
+
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: italic;
+										font-weight: normal;
+										src: url("` + dejavuserifItalic_woff + `") format('woff');
+									}
+
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: italic;
+										font-weight: bold;
+										src: url("` + dejavuserifBoldItalic_woff + `") format('woff');
+									}
+									
+									body {
+										font-family: 'Dejavu Serif', serif;
+										font-size:  ` + (fontSize ? fontSize : '12px') + `;
+									}
+
+									.row {
+										display: -webkit-flex;
+										display: flex;
+										flex-wrap: wrap;
+										-webkit-flex-wrap: wrap;
+										page-break-inside: avoid !important;
+									}
+
+									.page-break {
+										page-break-before: always !important;
+										padding-top: 1px;
+									}
+
+									.cell {
+										box-sizing: border-box;
+										padding : 2px;
+										-webkit-flex: 1;
+										word-wrap: break-word;
+									}
+
+									.cell-no-padding {
+										box-sizing: border-box;
+										-webkit-flex: 1;
+										word-wrap: break-word;
+									}
+
+									.centered {
+										-webkit-justify-content: center;
+										-webkit-align-items: center;
+										display: -webkit-flex;
+										text-align: center;
+									}
+
+									.centered-left {
+										-webkit-align-items: center;
+										display: -webkit-flex;
+										-webkit-justify-content: flex-start;
+									}
+
+									.centered-right {
+										-webkit-justify-content: flex-end;
+										-webkit-align-items: center;
+										display: -webkit-flex;
+									}
+									
+									.box {
+										border: 1px solid black;
+										margin: -1px 0px 0px -1px;
+									}
+
+									.boxNoBorder {
+										margin: -1px 0px 0px -1px;
+									}
+
+									pre {
+										white-space: pre-wrap;       /* css-3 */
+										white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+										white-space: -pre-wrap;      /* Opera 4-6 */
+										white-space: -o-pre-wrap;    /* Opera 7 */
+										word-wrap: break-word;       /* Internet Explorer 5.5+ */
+										font-size: 12px;
+										font-family: 'Dejavu Serif'; 
+									}
+								</style>
+								<meta charset="UTF-8">
+							</head>
+								<body>
+							` + html.replace(new RegExp('flex-basis:', 'g'), '-webkit-flex-basis:').replace(new RegExp('flex:', 'g'), '-webkit-flex:') + '</body>';
+
+							await withTimeout(page.setContent(content, { waitUntil: ['domcontentloaded'], timeout: PDF_CONTENT_TIMEOUT_MS }), PDF_CONTENT_TIMEOUT_MS, 'page.setContent');
+							await withTimeout(page.evaluateHandle('document.fonts.ready'), PDF_FONTS_TIMEOUT_MS, 'document.fonts.ready');
+
+							if (PDF_IMAGES_TIMEOUT_MS > 0) {
+								try {
+									await withTimeout(
+										page.waitForFunction(() => Array.from(document.images).every((img: any) => img.complete), { timeout: 0 }),
+										PDF_IMAGES_TIMEOUT_MS,
+										'waitForImages'
+									);
+								}
+								catch (errImages) {
+									if (errImages instanceof PdfTimeoutError) {
+										console.warn(new Date(), 'generatePDF timed out waiting for images', { fileName, attempt });
+									}
+									else {
+										throw errImages;
+									}
+								}
+							}
+							
+							let tmpFileName = objectIdHexString() + '.pdf';
+						
+							await withTimeout(page.pdf({
+								scale: 1,
+								landscape: orientation === 'portrait' ? false : true,
+								format: 'letter',
+								margin: {
+									top: '1cm',
+									bottom: '1cm',
+									left: '1cm',
+									right: '1cm'
+								},
+								printBackground: true,
+								displayHeaderFooter: true,
+								headerTemplate: `
+									<style>
+										#header { 
+											padding: 0 0 10px 10px !important; 
+										}
+									</style>
+									<span></span>
+								`,
+								footerTemplate: `
+									<style>
+										#footer { 
+											padding: 0 0 10px 10px !important;
+											font-size: 10px;
+											font-family: san-serif;
+										}
+									</style>
+									<div style="padding-bottom: 2px; padding-right: 15px; text-align: right; width: 100%;">
+										Page&nbsp;<span class="pageNumber"></span>&nbsp;of&nbsp;<span class="totalPages"></span>
+									</div>
+								`,
+								path: path.join(__dirname, (tmpFileName)),
+								timeout: PDF_RENDER_TIMEOUT_MS
+							}), PDF_RENDER_TIMEOUT_MS, 'page.pdf');
+
+							if (enableDebugFlag && enableDebugFlag.value) {
+								// Set viewport dimensions based on orientation
+								if (orientation === 'landscape') {
+									await page.setViewport({ width: 1100, height: 850 });
+							} 
+							else {
+								await page.setViewport({ width: 850, height: 1100 });
+							}
+						}
+
+						if (fs.existsSync(path.join(__dirname, (tmpFileName)))) {
+								try {
+									let data = fs.readFileSync(path.join(__dirname, (tmpFileName)));
+									fs.unlinkSync(path.join(__dirname, (tmpFileName)));
+									if (!upload) {
+										return 'data:application/pdf;base64,' + data.toString('base64');
+									}
+									else {
+										let fileData = 'data:application/pdf;base64,' + data.toString('base64');
+										return this.callMethod('uploadFileAndSave', fileName, fileData, (4 * Math.ceil(fileData.length / 3)), uploadFileOrder !== null ? uploadFileOrder : -1, uploadFileType, false);
+									}
+							}
+							catch (errRead) {
+								errRead.message = 'Error in Generate PDF: No file - ' + errRead.message;
+								throw errRead;
+							}
+						}
+						else {
+							console.log('No tmp file ', tmpFileName);
+							throw new Error('Error in Generate PDF: No tmp file');
+						}
+					}
+						catch (err) {
+							lastError = err;
+
+							if (browser) {
+								await safeCloseBrowser(browser);
+							}
+
+							if (attempt < maxAttempts) {
+								console.warn(new Date(), 'Retry generatePDF after error', {
+									attempt,
+									message: err && err.message ? err.message : err
+								});
+								continue;
+							}
+
+							console.error(new Date(), 'generatePDF failed', { fileName, attempt, message: err && err.message ? err.message : err });
+							throw err;
+						}
+						finally {
+							if (overallTimeoutHandle) {
+								clearTimeout(overallTimeoutHandle);
+							}
+
+							if (page) {
+								// eslint-disable-next-line no-restricted-syntax
+								await page.close().catch(() => {});
+								page = null;
+							}
+
+							await safeCloseBrowser(browser);
+							browser = null;
+
+							if (overallTimedOut) {
+								throw new PdfTimeoutError('generatePDF overall', PDF_OVERALL_TIMEOUT_MS);
+							}
+						}
+					}
+
+					throw lastError;
+				},
+			workerTaskWeight: 2,
+			maxConcurrency: 1,
+			timeoutOverride: 300000
+		},
+		generatePDFNoPageNumber: {
+			bypassSession: true,
+			check: new SimpleSchema({
+				html: {
+					type: String
+				},
+				fileName: {
+					type: String
+				},
+				orientation: {
+					type: String,
+					optional: true
+				},
+				fontSize: {
+					type: String,
+					optional: true
+				},
+				upload: {
+					type: Boolean,
+					optional: true
+				},
+				uploadFileOrder: {
+					type: Number,
+					optional: true
+				},
+				uploadFileType: {
+					type: String,
+					optional: true
+				}
+			}),
+			function: async function(html, fileName, orientation = 'portrait', fontSize = '12px', upload = false, uploadFileOrder = -1, uploadFileType = '') {
+				// console.log(new Date(), 'GENERATE PDF CALL', fileName, orientation, fontSize, upload);
+
+					const maxAttempts = 2;
+					let lastError: any = null;
+
+					for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+						let browser: puppeteer.Browser = null;
+						let page: puppeteer.Page = null;
+						let overallTimedOut = false;
+						let overallTimeoutHandle: NodeJS.Timeout = null;
+
+						try {
+							browser = await withTimeout(launchPDFBrowser(true, false), PDF_LAUNCH_TIMEOUT_MS, 'launchPDFBrowser');
+
+							overallTimeoutHandle = setTimeout(() => {
+								overallTimedOut = true;
+								console.error(new Date(), 'generatePDFNoPageNumber overall timeout hit', { fileName, attempt });
+								// eslint-disable-next-line no-restricted-syntax, promise/prefer-await-to-then
+								safeCloseBrowser(browser).catch(() => {});
+							}, PDF_OVERALL_TIMEOUT_MS);
+							
+							page = await browser.newPage();         // create new tab
+							page.setDefaultTimeout(PDF_CONTENT_TIMEOUT_MS);
+
+							let pathToFont = '';
+
+							if (fs.existsSync(path.join(__dirname, ('../private/fonts/dejavuserif.woff')))) {
+								pathToFont = path.join(__dirname, ('../private/fonts/'));
+						}
+						else {
+							if (fs.existsSync(path.join(this.clientDir, ('./private/fonts/dejavuserif.woff')))) {
+								pathToFont = path.join(this.clientDir, ('./private/fonts/'));
+							}
+							else {
+								pathToFont = '/usr/share/fonts/dejavu/';
+							}
+						}
+
+						let dejavuserif_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif.woff').buffer).toString('base64');
+						let dejavuserifBold_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif-bold.woff').buffer).toString('base64');
+						let dejavuserifItalic_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif-italic.woff').buffer).toString('base64');
+						let dejavuserifBoldItalic_woff = 'data:application/font-woff;base64,' + Buffer.from(fs.readFileSync(pathToFont + 'dejavuserif-bolditalic.woff').buffer).toString('base64');
+
+						let content = `
+							<head>
+								<style type="text/css">
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: normal;
+										font-weight: normal;
+										src: url("` + dejavuserif_woff + `") format('woff');
+									}
+
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: normal;
+										font-weight: bold;
+										src: url("` + dejavuserifBold_woff + `") format('woff');
+									}
+
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: italic;
+										font-weight: normal;
+										src: url("` + dejavuserifItalic_woff + `") format('woff');
+									}
+
+									@font-face {
+										font-family: 'Dejavu Serif';
+										font-style: italic;
+										font-weight: bold;
+										src: url("` + dejavuserifBoldItalic_woff + `") format('woff');
+									}
+									
+									body {
+										font-family: 'Dejavu Serif', serif;
+										font-size:  ` + (fontSize ? fontSize : '12px') + `;
+									}
+
+									.row {
+										display: -webkit-flex;
+										display: flex;
+										flex-wrap: wrap;
+										-webkit-flex-wrap: wrap;
+										page-break-inside: avoid !important;
+									}
+
+									.page-break {
+										page-break-before: always !important;
+										padding-top: 1px;
+									}
+
+									.cell {
+										box-sizing: border-box;
+										padding : 2px;
+										-webkit-flex: 1;
+										word-wrap: break-word;
+									}
+
+									.cell-no-padding {
+										box-sizing: border-box;
+										-webkit-flex: 1;
+										word-wrap: break-word;
+									}
+
+									.centered {
+										-webkit-justify-content: center;
+										-webkit-align-items: center;
+										display: -webkit-flex;
+										text-align: center;
+									}
+
+									.centered-left {
+										-webkit-align-items: center;
+										display: -webkit-flex;
+										-webkit-justify-content: flex-start;
+									}
+
+									.centered-right {
+										-webkit-justify-content: flex-end;
+										-webkit-align-items: center;
+										display: -webkit-flex;
+									}
+									
+									.box {
+										border: 1px solid black;
+										margin: -1px 0px 0px -1px;
+									}
+
+									.boxNoBorder {
+										margin: -1px 0px 0px -1px;
+									}
+
+									pre {
+										white-space: pre-wrap;       /* css-3 */
+										white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+										white-space: -pre-wrap;      /* Opera 4-6 */
+										white-space: -o-pre-wrap;    /* Opera 7 */
+										word-wrap: break-word;       /* Internet Explorer 5.5+ */
+										font-size: 12px;
+										font-family: 'Dejavu Serif'; 
+									}
+							</style>
+							<meta charset="UTF-8">
+						</head>
+							<body>
+						` + html.replace(new RegExp('flex-basis:', 'g'), '-webkit-flex-basis:').replace(new RegExp('flex:', 'g'), '-webkit-flex:') + `</body>`;
+
+							await withTimeout(page.setContent(content, { waitUntil: ['domcontentloaded'], timeout: PDF_CONTENT_TIMEOUT_MS }), PDF_CONTENT_TIMEOUT_MS, 'page.setContent');
+							await withTimeout(page.evaluateHandle('document.fonts.ready'), PDF_FONTS_TIMEOUT_MS, 'document.fonts.ready');
+
+							if (PDF_IMAGES_TIMEOUT_MS > 0) {
+								try {
+									await withTimeout(
+										page.waitForFunction(() => Array.from(document.images).every((img: any) => img.complete), { timeout: 0 }),
+										PDF_IMAGES_TIMEOUT_MS,
+										'waitForImages'
+									);
+								}
+								catch (errImages) {
+									if (errImages instanceof PdfTimeoutError) {
+										console.warn(new Date(), 'generatePDFNoPageNumber timed out waiting for images', { fileName, attempt });
+									}
+									else {
+										throw errImages;
+									}
+								}
+							}
+							
+							let tmpFileName = objectIdHexString() + '.pdf'; 
+							
+							await withTimeout(page.pdf({
+								scale: 1,
+								landscape: orientation === 'portrait' ? false : true,
+								format: 'letter',
+								margin: {
+									top: '1cm',
+									bottom: '1cm',
+									left: '1cm',
+									right: '1cm'
+								},
+								printBackground: true,
+								displayHeaderFooter: true,
+								headerTemplate: `
+									<style>
+										#header { 
+											padding: 0 0 10px 10px !important; 
+										}
+									</style>
+									<span></span>
+								`,
+								footerTemplate: `
+								<style>
+									#footer { 
+										padding: 0 0 10px 10px !important;
+										font-size: 10px;
+										font-family: san-serif;
+									}
+								</style>
+								<div style="padding-bottom: 2px; padding-right: 15px; text-align: right; width: 100%;">
+									
+								</div>
+								`,
+								path: path.join(__dirname, (tmpFileName)),
+								timeout: PDF_RENDER_TIMEOUT_MS
+							}), PDF_RENDER_TIMEOUT_MS, 'page.pdf');
+							
+							if (fs.existsSync(path.join(__dirname, (tmpFileName)))) {
+									try {
+										let data = fs.readFileSync(path.join(__dirname, (tmpFileName)))
+										fs.unlinkSync(path.join(__dirname, (tmpFileName)));
+									if (!upload) {
+										return 'data:application/pdf;base64,' + data.toString('base64');
+									}
+									else {
+										let fileData = 'data:application/pdf;base64,' + data.toString('base64');
+										return this.callMethod('uploadFileAndSave', fileName, fileData, (4 * Math.ceil(fileData.length / 3)), uploadFileOrder !== null ? uploadFileOrder : -1, uploadFileType, false);
+									}
+								}
+								catch (errRead) {
+									errRead.message = 'Error in Generate PDF No Page Number: No file - ' + errRead.message;
+									throw errRead;
+								}
+							}
+						else {
+								console.log('No tmp file ', tmpFileName);
+								throw new Error('Error in Generate PDF No Page Number: No tmp file');
+							}
+					}
+						catch (err) {
+							lastError = err;
+
+							if (browser) {
+								await safeCloseBrowser(browser);
+							}
+
+							if (attempt < maxAttempts) {
+								console.warn(new Date(), 'Retry generatePDFNoPageNumber after error', {
+									attempt,
+									message: err && err.message ? err.message : err
+								});
+								continue;
+							}
+
+							console.error(new Date(), 'generatePDFNoPageNumber failed', { fileName, attempt, message: err && err.message ? err.message : err });
+							throw err;
+						}
+						finally {
+							if (overallTimeoutHandle) {
+								clearTimeout(overallTimeoutHandle);
+							}
+
+							if (page) {
+								// eslint-disable-next-line no-restricted-syntax
+								await page.close().catch(() => {});
+								page = null;
+							}
+
+							await safeCloseBrowser(browser);
+							browser = null;
+
+							if (overallTimedOut) {
+								throw new PdfTimeoutError('generatePDFNoPageNumber overall', PDF_OVERALL_TIMEOUT_MS);
+							}
+						}
+					}
+
+					throw lastError;
+				},
+			workerTaskWeight: 2,
+			maxConcurrency: 1,
+			timeoutOverride: 300000
+		},
+		mergePDFResolve: {
+			bypassSession: true,
+			check: new SimpleSchema({
+				fileKeys: {
+					type: Array
+				},
+				'fileKeys.$': {
+					type: String
+				},
+				fileName: {
+					type: String
+				},
+				fileType: {
+					type: String,
+					optional: true
+				}
+			}),
+			function: async function(fileKeys: string[], fileName: string, fileType?: string) {
+				let resSigneds = null;
+
+				try {
+					resSigneds = await this.callMethod('getSignedUrls', fileKeys, 900);
+				}
+				catch (err) {
+					err.message = 'Error in Merge PDF Resolve: PDF Merge - Get Signed URLs - ' + err.message;
+					throw err;
+				}
+
+				if (!resSigneds || !resSigneds.length) {
+					throw new Error('Error in Merge PDF Resolve: PDF Merge - No signed urls');
+				}
+
+				const mergedPdf = await PDFDocument.create();
+
+				for (let i = 0; i < resSigneds.length; i++) {
+					let signedUrl = resSigneds[i];
+					let fileKey = fileKeys && fileKeys[i] ? fileKeys[i] : '';
+
+					let response = null;
+					try {
+						response = await axios.get(signedUrl, {
+							responseType: 'arraybuffer'
+						});
+					}
+					catch (err) {
+						err.message = `Error in Merge PDF Resolve: PDF Merge - Download failed (${fileKey || 'unknown key'}) - ${err.message}`;
+						throw err;
+					}
+
+					if (!response || response.status !== 200) {
+						throw new Error(`Error in Merge PDF Resolve: PDF Merge - Download failed (${fileKey || 'unknown key'}) - status: ${response ? response.status : 'unknown'}`);
+					}
+
+					let contentTypeHeader = response.headers ? response.headers['content-type'] : '';
+					let contentType = (contentTypeHeader ? String(contentTypeHeader) : '').toLowerCase().split(';')[0].trim();
+
+					let responseData = response.data;
+					let fileDataBuffer = Buffer.isBuffer(responseData) ? responseData : Buffer.from(responseData);
+
+					if (!fileDataBuffer) {
+						throw new Error(`Error in Merge PDF Resolve: PDF Merge - No file data returned (${fileKey || 'unknown key'})`);
+					}
+
+					let fileKeyLower = fileKey ? fileKey.toLowerCase() : '';
+					let isPdf = contentType === 'application/pdf' || contentType === 'application/x-pdf' || fileKeyLower.endsWith('.pdf');
+					let isJpg = contentType === 'image/jpeg' || contentType === 'image/jpg' || fileKeyLower.endsWith('.jpg') || fileKeyLower.endsWith('.jpeg');
+					let isPng = contentType === 'image/png' || fileKeyLower.endsWith('.png');
+
+					try {
+						if (isPdf) {
+							const pdf = await PDFDocument.load(fileDataBuffer as any, { updateMetadata: false, parseSpeed: ParseSpeeds.Fastest, ignoreEncryption: true });
+							let pageCount = pdf.getPageCount();
+
+							for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+								const copiedPages = await mergedPdf.copyPages(pdf, [pageIndex]);
+								mergedPdf.addPage(copiedPages[0]);
+
+								if (pageIndex > 0 && pageIndex % 25 === 0) {
+									// eslint-disable-next-line no-restricted-syntax
+									await new Promise(resolve => setImmediate(resolve));
+								}
+							}
+						}
+						else if (isJpg) {
+							const img = await mergedPdf.embedJpg(fileDataBuffer as any);
+							const page = mergedPdf.addPage();
+							let imgDim = img.scaleToFit(page.getWidth() * 0.75, page.getHeight() * 0.75);
+							page.drawImage(img, {
+								x: page.getWidth() / 2 - imgDim.width / 2,
+								y: page.getHeight() / 2 - imgDim.height / 2,
+								width: imgDim.width,
+								height: imgDim.height,
+							});
+						}
+						else if (isPng) {
+							const img = await mergedPdf.embedPng(fileDataBuffer as any);
+							const page = mergedPdf.addPage();
+							let imgDim = img.scaleToFit(page.getWidth() * 0.75, page.getHeight() * 0.75);
+							page.drawImage(img, {
+								x: page.getWidth() / 2 - imgDim.width / 2,
+								y: page.getHeight() / 2 - imgDim.height / 2,
+								width: imgDim.width,
+								height: imgDim.height,
+							});
+						}
+						else {
+							console.log('Error - unsupported!!', { fileKey, contentType });
+							throw new Error(`Error in Merge PDF Resolve: Unsupported document type (${contentType || 'unknown content-type'})`);
+						}
+					}
+					catch (err) {
+						err.message = `Error in Merge PDF Resolve: PDF Merge - Error processing file (${fileKey || 'unknown key'}) - ${err.message}`;
+						throw err;
+					}
+					finally {
+						response = null;
+						responseData = null;
+						fileDataBuffer = null;
+					}
+				}
+
+				let mergedPDFUint8 = await mergedPdf.save();
+				let mergedPDFBuffer = Buffer.from(mergedPDFUint8.buffer, mergedPDFUint8.byteOffset, mergedPDFUint8.byteLength);
+
+				return this.callMethod('uploadPDFBufferAndSave', fileName, mergedPDFBuffer, mergedPDFBuffer.byteLength, -1, fileType || 'pdf');
+			},
+			workerTaskWeight: 2,
+			maxConcurrency: 1,
+			timeoutOverride: 300000
+		},		
+		mergePDFResolveNoSave: {
+			bypassSession: true,
+			check: new SimpleSchema({
+				fileKeys: {
+					type: Array
+				},
+				'fileKeys.$': {
+					type: String
+				}
+			}),
+			function: async function(fileKeys: string[]) {
+				try {
+					let resSigneds = await this.callMethod('getSignedUrls', fileKeys, 900);
+					if (resSigneds && resSigneds.length) {
+						let promises: any[] = [];
+
+						resSigneds.forEach((signedUrl) => {
+							promises.push(this.callMethod('getDataURIfromURL', signedUrl));
+						});
+						
+						let fileDatas = await Promise.all(promises);
+						const mergedPdf = await PDFDocument.create();
+
+						for (let i = 0; i < fileDatas.length; i++) {
+							let fileData = fileDatas[i];
+
+							if (fileData) {
+								try {
+									if (fileData.startsWith('data:application/pdf;base64,')) {
+										const pdf = await PDFDocument.load(fileData, { updateMetadata: false, parseSpeed: ParseSpeeds.Fastest, ignoreEncryption: true});
+										const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+										copiedPages.forEach((page) => {
+											mergedPdf.addPage(page);
+										});
+									}
+									else if (fileData.startsWith('data:image/jpeg;base64,/9j/') || fileData.startsWith('data:image/png;base64,/9j/')) {
+										const pdf = await PDFDocument.create();
+										const img = await pdf.embedJpg(fileData);
+										const page = pdf.addPage();
+										let imgDim = img.scaleToFit(page.getWidth() * 0.75, page.getHeight() * 0.75);
+										page.drawImage(img, {
+											x: page.getWidth() / 2 - imgDim.width / 2,
+											y: page.getHeight() / 2 - imgDim.height / 2,
+											width: imgDim.width,
+											height: imgDim.height,
+										});
+										const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+										copiedPages.forEach((page) => {
+											mergedPdf.addPage(page);
+										});
+									}
+									else if (fileData.startsWith('data:image/png;base64,iVBOR')) {
+										const pdf = await PDFDocument.create();
+										const img = await pdf.embedPng(fileData);
+										const page = pdf.addPage();
+										let imgDim = img.scaleToFit(page.getWidth() * 0.75, page.getHeight() * 0.75);
+										page.drawImage(img, {
+											x: page.getWidth() / 2 - imgDim.width / 2,
+											y: page.getHeight() / 2 - imgDim.height / 2,
+											width: imgDim.width,
+											height: imgDim.height,
+										});
+										const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+										copiedPages.forEach((page) => {
+											mergedPdf.addPage(page);
+										});
+									}
+									else {
+										console.log('Error - unsupported!!', fileData.slice(0, 60));
+									}
+								}
+								catch (error) {
+									console.log('Error processing fileData:', fileData.slice(0, 60), error);
+								}
+							}
+							else {
+								console.log('Error - no filedata!!', fileData);
+							}
+						}
+
+						let mergedPDFUint8 = await mergedPdf.save();
+
+						const b64PDF = 'data:application/pdf;base64,' + Buffer.from(mergedPDFUint8).toString('base64');
+						
+						return b64PDF;
+					}
+					else {
+						throw new Error('Error in Merge PDF Resolve No Save: No signed urls');
+					}
+				}
+				catch (err) {
+					err.message = `Error in Merge PDF Resolve: ${err.message}`;
+					throw err;
+				}
+			},
+			workerTaskWeight: 2,
+			maxConcurrency: 1,
+			timeoutOverride: 300000
+		},
+		mergePDFResolveHtml: {
+			bypassSession: true,
+			check: new SimpleSchema({
+				htmls: {
+					type: Array
+				},
+				'htmls.$': {
+					type: String
+				},
+				fileName: {
+					type: String
+				},
+				fileType: {
+					type: String,
+					optional: true
+				},
+				save: {
+					type: Boolean,
+					optional: true
+				}
+			}),
+			function: async function(htmls: string[], fileName: string, fileType?: string, save = true) {
+				const mergedPdf = await PDFDocument.create();
+
+				for (let i = 0; i < htmls.length; i++) {
+					let fileData = htmls[i];
+
+					if (fileData) {
+						try {
+							if (fileData.startsWith('data:application/pdf;base64,')) {
+								const pdf = await PDFDocument.load(fileData, { updateMetadata: false, parseSpeed: ParseSpeeds.Fastest, ignoreEncryption: true });
+								const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+								copiedPages.forEach((page) => {
+									mergedPdf.addPage(page);
+								});
+							}
+							else if (fileData.startsWith('data:image/jpeg;base64,/9j/') || fileData.startsWith('data:image/png;base64,/9j/')) {
+								const pdf = await PDFDocument.create();
+								const img = await pdf.embedJpg(fileData);
+								const page = pdf.addPage();
+								let imgDim = img.scaleToFit(page.getWidth() * 0.75, page.getHeight() * 0.75);
+								page.drawImage(img, {
+									x: page.getWidth() / 2 - imgDim.width / 2,
+									y: page.getHeight() / 2 - imgDim.height / 2,
+									width: imgDim.width,
+									height: imgDim.height,
+								});
+								const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+								copiedPages.forEach((page) => {
+									mergedPdf.addPage(page);
+								});
+							}
+							else if (fileData.startsWith('data:image/png;base64,iVBOR')) {
+								const pdf = await PDFDocument.create();
+								const img = await pdf.embedPng(fileData);
+								const page = pdf.addPage();
+								let imgDim = img.scaleToFit(page.getWidth() * 0.75, page.getHeight() * 0.75);
+								page.drawImage(img, {
+									x: page.getWidth() / 2 - imgDim.width / 2,
+									y: page.getHeight() / 2 - imgDim.height / 2,
+									width: imgDim.width,
+									height: imgDim.height,
+								});
+								const copiedPages = await mergedPdf.copyPages(pdf, pdf.getPageIndices());
+								copiedPages.forEach((page) => {
+									mergedPdf.addPage(page);
+								});
+							}
+							else {
+								console.log('Error - unsupported!!', fileData.slice(0, 60));
+								throw new Error('Error in Merge PDF Resolve HTML: Unsupported file - ' + fileData.slice(0, 60));
+							}
+						}
+						catch (error) {
+							console.log('Error processing fileData:', fileData.slice(0, 60), error);
+							error.message = `Error in Merge PDF Resolve HTML: Error processing filedata - ${error.message}`;
+							throw error;
+						}
+					}
+					else {
+						console.log('Error - no filedata!!', fileData);
+						throw new Error('Error in Merge PDF Resolve HTML: No File data');
+					}
+				}
+
+				let mergedPDFUint8 = await mergedPdf.save();
+
+				const b64PDF = 'data:application/pdf;base64,' + Buffer.from(mergedPDFUint8).toString('base64');
+
+				if (save) {
+					return this.callMethod('uploadFileAndSave', fileName, b64PDF, (4 * Math.ceil(b64PDF.length / 3)), -1, fileType, false);
+				}
+				else {
+					return b64PDF;
+				}
+			},
+			workerTaskWeight: 2,
+			maxConcurrency: 1,
+			timeoutOverride: 300000
+		}
+	});
+}