@things-factory/integration-headless 7.0.53 → 7.0.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-headless",
-  "version": "7.0.53",
+  "version": "7.0.54",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -29,5 +29,5 @@
     "ejs": "^3.1.10",
     "pdf-lib": "^1.17.1"
   },
-  "gitHead": "96b4308aff1d312343c647a80823658e78b03824"
+  "gitHead": "14a3320fb61bd0a47c147d4c3ff8310de6172f61"
 }

package/server/engine/task/headless-pdf-capture-board.ts

@@ -1,5 +1,4 @@
 import { TaskRegistry } from '@things-factory/integration-base'
-
 import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
 import { BoardFunc } from '@things-factory/board-service'
 
@@ -76,7 +75,7 @@ export async function HeadlessPDFCaptureBoard(step, context) {
 
     // PDF 생성 및 추가
     const htmlContent = '' // 보드에서 직접 렌더링되므로 HTML 컨텐츠가 비어있음
-    await pdfUtil.processPageAndGeneratePDF({ ...step.params, width, height }, htmlContent)
+    await pdfUtil.processPageAndGeneratePDF(pageOptions, htmlContent) // pageOptions 사용
 
     return {
       data: context.__headless_pdf

package/server/engine/task/headless-pdf-open.ts

@@ -1,243 +1,64 @@
-import * as ejs from 'ejs'
 import { PDFDocument } from 'pdf-lib'
 import { TaskRegistry } from '@things-factory/integration-base'
-import { ConnectionManager } from '@things-factory/integration-base'
 import { access } from '@things-factory/utils'
+import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
 
 async function HeadlessPDFOpen(step, context) {
-  var { connection: connectionName, params: stepOptions } = step
-  var {
-    accessor,
-    coverPage,
-    lastPage,
+  const { connection: connectionName, params: stepOptions } = step
+  const { accessor, coverPage, lastPage, header, footer, watermark, fileName } = stepOptions || {}
+
+  const { data } = context
+
+  // Create a new PDF document using pdf-lib
+  const pdfDoc = await PDFDocument.create()
+
+  const pdfInfo = {
+    pdfDoc,
     header,
     footer,
     watermark,
     fileName,
-    format,
-    width,
-    height,
-    marginTop,
-    marginBottom,
-    marginLeft,
-    marginRight,
-    scale,
-    printBackground,
-    landscape,
-    preferCSSPageSize
-  } = stepOptions || {}
-  const { data, logger } = context
+    pageCount: 0
+  } as any
 
-  const headlessPool = ConnectionManager.getConnectionInstanceByName(context.domain, connectionName)
-  let browser
+  context.__headless_pdf = pdfInfo
 
-  // Create a new PDF document using pdf-lib
-  const pdfDoc = await PDFDocument.create()
+  const pdfUtil = new PDFCaptureUtil(context)
+  await pdfUtil.initBrowser(connectionName)
 
   try {
-    browser = await headlessPool.acquire()
-    const page = await browser.newPage()
-
     const templateInput = access(accessor, data)
 
-    const renderTemplateSafely = (template, data) => {
-      try {
-        return ejs.render(template, data)
-      } catch (error) {
-        logger.warn(`Template rendering error: ${error.message}`)
-        return template
-      }
-    }
-
     // Convert Cover Page to PDF and add it to the document (if provided)
     if (coverPage) {
-      const renderedCoverPage = renderTemplateSafely(coverPage, templateInput)
-
-      await page.setContent(renderedCoverPage)
-
-      // Apply header, footer, and watermark using Puppeteer
-      // Apply header, footer, and watermark using Puppeteer
-      if (header || footer || watermark) {
-        await page.evaluate(
-          ({ header, footer, watermark, isLandscape }) => {
-            const setPositioning = (element, position) => {
-              element.style.position = 'fixed'
-              element.style.left = '0'
-              element.style.width = '100%'
-              element.style.textAlign = 'center'
-              element.style.fontSize = '12px'
-              if (position === 'header') {
-                element.style.top = '0'
-              } else if (position === 'footer') {
-                element.style.bottom = '0'
-              }
-            }
-
-            // if (header) {
-            //   const headerElement = document.createElement('div')
-            //   headerElement.innerHTML = header
-            //   setPositioning(headerElement, 'header')
-            //   document.body.appendChild(headerElement)
-            // }
-
-            // if (footer) {
-            //   const footerElement = document.createElement('div')
-            //   footerElement.innerHTML = footer
-            //   setPositioning(footerElement, 'footer')
-            //   document.body.appendChild(footerElement)
-            // }
-
-            if (watermark) {
-              const watermarkElement = document.createElement('div')
-              watermarkElement.innerHTML = watermark
-              watermarkElement.style.position = 'fixed'
-              watermarkElement.style.top = isLandscape ? '40%' : '50%'
-              watermarkElement.style.left = '50%'
-              watermarkElement.style.transform = 'translate(-50%, -50%) rotate(-45deg)'
-              watermarkElement.style.opacity = '0.2'
-              watermarkElement.style.fontSize = '50px'
-              watermarkElement.style.color = 'red'
-              watermarkElement.style.pointerEvents = 'none'
-              watermarkElement.style.zIndex = '9999'
-              document.body.appendChild(watermarkElement)
-            }
-          },
-          { header, footer, watermark, isLandscape: landscape }
-        )
-      }
-
-      const pageOptions = {
-        format,
-        width,
-        height,
-        margin: {
-          top: marginTop,
-          right: marginRight,
-          bottom: marginBottom,
-          left: marginLeft
-        },
-        scale,
-        printBackground,
-        landscape,
-        displayHeaderFooter: false, // Handled via Puppeteer directly
-        preferCSSPageSize
-      }
-
-      const coverPageBuffer = await page.pdf(pageOptions)
-      const coverPageDoc = await PDFDocument.load(coverPageBuffer)
-      const coverPages = await pdfDoc.copyPages(coverPageDoc, coverPageDoc.getPageIndices())
-      coverPages.forEach(page => pdfDoc.addPage(page))
+      const renderedCoverPage = pdfUtil.renderTemplate(coverPage, templateInput)
+      await pdfUtil.processPageAndGeneratePDF(stepOptions, renderedCoverPage)
     }
 
     var lastPageBuffer
 
     // Process Last Page (if provided) but add it later in the save task
     if (lastPage) {
-      const renderedLastPage = renderTemplateSafely(lastPage, templateInput)
-      await page.setContent(renderedLastPage)
-
-      // Apply header, footer, and watermark using Puppeteer
-      if (header || footer || watermark) {
-        await page.evaluate(
-          ({ header, footer, watermark, isLandscape }) => {
-            const setPositioning = (element, position) => {
-              element.style.position = 'fixed'
-              element.style.left = '0'
-              element.style.width = '100%'
-              element.style.textAlign = 'center'
-              element.style.fontSize = '12px'
-              if (position === 'header') {
-                element.style.top = '0'
-              } else if (position === 'footer') {
-                element.style.bottom = '0'
-              }
-            }
-
-            // if (header) {
-            //   const headerElement = document.createElement('div')
-            //   headerElement.innerHTML = header
-            //   setPositioning(headerElement, 'header')
-            //   document.body.appendChild(headerElement)
-            // }
-
-            // if (footer) {
-            //   const footerElement = document.createElement('div')
-            //   footerElement.innerHTML = footer
-            //   setPositioning(footerElement, 'footer')
-            //   document.body.appendChild(footerElement)
-            // }
+      const renderedLastPage = pdfUtil.renderTemplate(lastPage, templateInput)
+      lastPageBuffer = await pdfUtil.generateLastPageBuffer(stepOptions, renderedLastPage)
+    }
 
-            if (watermark) {
-              const watermarkElement = document.createElement('div')
-              watermarkElement.innerHTML = watermark
-              watermarkElement.style.position = 'fixed'
-              watermarkElement.style.top = isLandscape ? '40%' : '50%'
-              watermarkElement.style.left = '50%'
-              watermarkElement.style.transform = 'translate(-50%, -50%) rotate(-45deg)'
-              watermarkElement.style.opacity = '0.2'
-              watermarkElement.style.fontSize = '50px'
-              watermarkElement.style.color = 'red'
-              watermarkElement.style.pointerEvents = 'none'
-              watermarkElement.style.zIndex = '9999'
-              document.body.appendChild(watermarkElement)
-            }
-          },
-          { header, footer, watermark, isLandscape: landscape }
-        )
-      }
+    await pdfUtil.closeBrowser()
 
-      const pageOptions = {
-        format,
-        width,
-        height,
-        margin: {
-          top: marginTop,
-          right: marginRight,
-          bottom: marginBottom,
-          left: marginLeft
-        },
-        scale,
-        printBackground,
-        landscape,
-        displayHeaderFooter: false, // Handled via Puppeteer directly
-        preferCSSPageSize
-      }
+    pdfInfo.lastPageBuffer = lastPageBuffer
+    pdfInfo.pageCount = pdfDoc.getPageCount()
 
-      lastPageBuffer = await page.pdf(pageOptions)
+    return {
+      data: pdfInfo
     }
-
-    await page.close()
-    headlessPool.release(browser)
   } catch (error) {
-    if (browser) {
-      await browser.close()
-    }
+    await pdfUtil.closeBrowser()
     throw error
   }
-
-  const pdfInfo = {
-    pdfDoc,
-    lastPageBuffer,
-    header,
-    footer,
-    watermark,
-    fileName,
-    pageCount: pdfDoc.getPageCount()
-  }
-
-  context.__headless_pdf = pdfInfo
-
-  return {
-    data: pdfInfo
-  }
 }
 
 HeadlessPDFOpen.parameterSpec = [
-  {
-    type: 'scenario-step-input',
-    name: 'accessor',
-    label: 'accessor'
-  },
+  ...getCommonParameterSpec(),
   {
     type: 'textarea',
     name: 'coverPage',
@@ -269,91 +90,6 @@ HeadlessPDFOpen.parameterSpec = [
     type: 'string',
     name: 'fileName',
     label: 'filename'
-  },
-  {
-    type: 'select',
-    name: 'format',
-    label: 'page-format',
-    property: {
-      options: [
-        { display: '', value: '' },
-        { display: 'A4', value: 'A4' },
-        { display: 'A3', value: 'A3' },
-        { display: 'Letter', value: 'Letter' },
-        { display: 'Legal', value: 'Legal' }
-      ]
-    },
-    description: 'Select the paper format for the PDF'
-  },
-  {
-    type: 'string',
-    name: 'width',
-    label: 'page-width',
-    placeholder: '(e.g., "8.5in", "21cm", "600px")',
-    description: 'Specify the width of the page (e.g., "8.5in", "21cm", "600px")'
-  },
-  {
-    type: 'string',
-    name: 'height',
-    label: 'page-height',
-    placeholder: '(e.g., "11in", "29.7cm", "800px")',
-    description: 'Specify the height of the page (e.g., "11in", "29.7cm", "800px")'
-  },
-  {
-    type: 'string',
-    name: 'marginTop',
-    label: 'page-margin-top',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the top margin for the page'
-  },
-  {
-    type: 'string',
-    name: 'marginBottom',
-    label: 'page-margin-bottom',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the bottom margin for the page'
-  },
-  {
-    type: 'string',
-    name: 'marginLeft',
-    label: 'page-margin-left',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the left margin for the page'
-  },
-  {
-    type: 'string',
-    name: 'marginRight',
-    label: 'page-margin-right',
-    placeholder: '(e.g., "0.5in", "1cm", "100px")',
-    description: 'Set the right margin for the page'
-  },
-  {
-    type: 'number',
-    name: 'scale',
-    label: 'page-scale',
-    defaultValue: 1,
-    description: 'Set the scale of the page content (default is 1)'
-  },
-  {
-    type: 'boolean',
-    name: 'printBackground',
-    label: 'print-background',
-    defaultValue: true,
-    description: 'Include background graphics when printing the page'
-  },
-  {
-    type: 'boolean',
-    name: 'landscape',
-    label: 'landscape',
-    defaultValue: false,
-    description: 'Print the PDF in landscape orientation'
-  },
-  {
-    type: 'boolean',
-    name: 'preferCSSPageSize',
-    label: 'prefer-css-page-size',
-    defaultValue: false,
-    description: 'Whether to prefer the CSS-defined page size over the given width and height'
   }
 ]
 

package/server/engine/task/headless-pdf-save.ts

@@ -1,12 +1,11 @@
 import { PDFDocument } from 'pdf-lib'
-const { Readable } = require('stream')
-
+import { Readable } from 'stream'
 import { TaskRegistry } from '@things-factory/integration-base'
 import { Attachment, createAttachment } from '@things-factory/attachment-base'
 import { getRepository } from '@things-factory/shell'
 
 async function HeadlessPDFSave(step, context) {
-  var { domain, user, __headless_pdf } = context
+  const { domain, user, __headless_pdf } = context
 
   if (!__headless_pdf || !__headless_pdf.pdfDoc) {
     throw new Error(
@@ -18,16 +17,39 @@ async function HeadlessPDFSave(step, context) {
 
   // Add last page if it exists
   if (__headless_pdf.lastPageBuffer) {
-    const lastPageDoc = await PDFDocument.load(__headless_pdf.lastPageBuffer)
-    const copiedLastPages = await pdfDoc.copyPages(lastPageDoc, lastPageDoc.getPageIndices())
-    copiedLastPages.forEach(page => pdfDoc.addPage(page))
+    await appendLastPageToPDF(pdfDoc, __headless_pdf.lastPageBuffer)
   }
 
   const pdfBytes = await pdfDoc.save()
+  const finalFileName = generateFileName(__headless_pdf.fileName)
+
+  const savedAttachment = await savePDFToFile(pdfBytes, finalFileName, domain, user)
+  const attachment = await getAttachmentDetails(savedAttachment.id)
 
-  const finalFileName = __headless_pdf.fileName || `document-${Date.now()}.pdf`
+  return {
+    data: {
+      id: attachment.id,
+      name: attachment.name,
+      path: attachment.path,
+      mimetype: attachment.mimetype,
+      refBy: attachment.refBy,
+      fullpath: attachment.fullpath
+    }
+  }
+}
+
+async function appendLastPageToPDF(pdfDoc, lastPageBuffer) {
+  const lastPageDoc = await PDFDocument.load(lastPageBuffer)
+  const copiedLastPages = await pdfDoc.copyPages(lastPageDoc, lastPageDoc.getPageIndices())
+  copiedLastPages.forEach(page => pdfDoc.addPage(page))
+}
 
-  const saved = await createAttachment(
+function generateFileName(fileName) {
+  return fileName || `document-${Date.now()}.pdf`
+}
+
+async function savePDFToFile(pdfBytes, finalFileName, domain, user) {
+  return await createAttachment(
     null,
     {
       attachment: {
@@ -51,21 +73,12 @@ async function HeadlessPDFSave(step, context) {
       state: { domain, user }
     }
   )
+}
 
-  const attachment = await getRepository(Attachment).findOne({
-    where: { id: saved.id }
+async function getAttachmentDetails(attachmentId) {
+  return await getRepository(Attachment).findOne({
+    where: { id: attachmentId }
   })
-
-  return {
-    data: {
-      id: attachment.id,
-      name: attachment.name,
-      path: attachment.path,
-      mimetype: attachment.mimetype,
-      refBy: attachment.refBy,
-      fullpath: attachment.fullpath
-    }
-  }
 }
 
 HeadlessPDFSave.parameterSpec = []

package/server/engine/task/pdf-capture-util.ts

@@ -58,8 +58,7 @@ export class PDFCaptureUtil {
     }
   }
 
-  async generatePDFContent(page: Page, htmlContent: string, pageOptions: any): Promise<PDFDocument> {
-    await page.setContent(htmlContent)
+  async generatePDFContent(page: Page, pageOptions: any): Promise<PDFDocument> {
     const contentBuffer = await page.pdf(pageOptions)
     const contentPdfDoc = await PDFDocument.load(contentBuffer)
     return contentPdfDoc
@@ -76,15 +75,19 @@ export class PDFCaptureUtil {
 
     const page = await this.browser.newPage()
 
+    // 페이지 컨텐츠 설정
+    await page.setContent(htmlContent, { waitUntil: 'networkidle0' }) // HTML 컨텐츠가 완전히 로드될 때까지 대기
+
+    // 페이지가 완전히 로드된 후에 워터마크와 머릿글 적용
     const { __headless_pdf } = this.context
     const { header, footer, watermark, landscape } = __headless_pdf
 
     if (header || footer || watermark) {
-      await this.applyHeaderFooterWatermark(page, { header, footer, watermark, landscape })
+      await this.applyHeaderFooterWatermark(page, { header, footer, watermark, landscape, data: __headless_pdf })
     }
 
     const pageOptions = this.buildPageOptions(stepOptions)
-    const contentPdfDoc = await this.generatePDFContent(page, htmlContent, pageOptions)
+    const contentPdfDoc = await this.generatePDFContent(page, pageOptions)
     await this.appendPDFContentToDocument(__headless_pdf.pdfDoc, contentPdfDoc)
     await page.close()
   }
@@ -127,10 +130,16 @@ export class PDFCaptureUtil {
 
   async applyHeaderFooterWatermark(
     page: Page,
-    { header, footer, watermark, landscape }: { header: string; footer: string; watermark: string; landscape: boolean }
+    {
+      header,
+      footer,
+      watermark,
+      landscape,
+      data
+    }: { header: string; footer: string; watermark: string; landscape: boolean; data: any }
   ) {
     await page.evaluate(
-      ({ header, footer, watermark, landscape }) => {
+      ({ header, footer, watermark, landscape, data }) => {
         const setPositioning = (element: HTMLElement, position: 'header' | 'footer') => {
           element.style.position = 'fixed'
           element.style.left = '0'
@@ -139,6 +148,8 @@ export class PDFCaptureUtil {
           element.style.fontSize = '12px'
           element.style.margin = '0'
           element.style.padding = '0'
+          element.style.zIndex = '1000'
+
           if (position === 'header') {
             element.style.top = '0'
           } else if (position === 'footer') {
@@ -175,9 +186,41 @@ export class PDFCaptureUtil {
           document.body.appendChild(watermarkElement)
         }
       },
-      { header, footer, watermark, landscape }
+      {
+        header: header && this.renderTemplate(header, data),
+        footer: footer && this.renderTemplate(footer, data),
+        watermark: watermark && this.renderTemplate(watermark, data),
+        landscape,
+        data
+      }
     )
   }
+
+  /**
+   * Generates a PDF buffer for the last page.
+   * @param stepOptions - Options used for generating the PDF.
+   * @param htmlContent - HTML content to be converted to PDF.
+   * @returns {Promise<Uint8Array>} - The generated PDF as a buffer.
+   */
+  async generateLastPageBuffer(stepOptions: StepOptions, htmlContent: string): Promise<Uint8Array> {
+    if (!this.browser) throw new Error('Browser not initialized. Call initBrowser() first.')
+
+    const page = await this.browser.newPage()
+
+    // 페이지에 HTML 콘텐츠를 설정합니다.
+    await page.setContent(htmlContent, { waitUntil: 'networkidle0' })
+
+    // 페이지 옵션 설정
+    const pageOptions = this.buildPageOptions(stepOptions)
+
+    // PDF를 생성하고 버퍼를 반환합니다.
+    const lastPageBuffer = await page.pdf(pageOptions)
+
+    // 페이지 닫기
+    await page.close()
+
+    return lastPageBuffer
+  }
 }
 
 export function getCommonParameterSpec() {