@things-factory/integration-headless 7.0.39 → 7.0.40

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

@@ -2,39 +2,208 @@ 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'
 
 async function HeadlessPDFOpen(step, context) {
   var { connection: connectionName, params: stepOptions } = step
   var {
+    accessor,
     coverPage,
     lastPage,
     header,
     footer,
     watermark,
-    fileName // 추가된 파일 이름
+    fileName,
+    format,
+    width,
+    height,
+    marginTop,
+    marginBottom,
+    marginLeft,
+    marginRight,
+    scale,
+    printBackground,
+    landscape,
+    preferCSSPageSize
   } = stepOptions || {}
-
-  const pdf = await PDFDocument.create()
+  const { data, logger } = context
 
   const headlessPool = ConnectionManager.getConnectionInstanceByName(context.domain, connectionName)
   let browser
 
+  // Create a new PDF document using pdf-lib
+  const pdfDoc = await PDFDocument.create()
+
   try {
     browser = await headlessPool.acquire()
     const page = await browser.newPage()
 
-    // Cover Page를 PDF로 변환
+    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) {
-      await page.setContent(coverPage)
-      const coverPageBuffer = await page.pdf()
-      coverPage = coverPageBuffer
+      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))
     }
 
-    // Last Page를 PDF로 변환
+    var lastPageBuffer
+
+    // Process Last Page (if provided) but add it later in the save task
     if (lastPage) {
-      await page.setContent(lastPage)
-      const lastPageBuffer = await page.pdf()
-      lastPage = lastPageBuffer
+      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)
+            // }
+
+            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
+      }
+
+      lastPageBuffer = await page.pdf(pageOptions)
     }
 
     await page.close()
@@ -46,25 +215,29 @@ async function HeadlessPDFOpen(step, context) {
     throw error
   }
 
-  const data = {
-    pdf,
-    coverPage,
-    lastPage,
+  const pdfInfo = {
+    pdfDoc,
+    lastPageBuffer,
     header,
     footer,
     watermark,
     fileName,
-    pageCount: 0
+    pageCount: pdfDoc.getPageCount()
   }
 
-  context.__headless_pdf = data
+  context.__headless_pdf = pdfInfo
 
   return {
-    data
+    data: pdfInfo
   }
 }
 
 HeadlessPDFOpen.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
   {
     type: 'textarea',
     name: 'coverPage',
@@ -96,8 +269,94 @@ 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'
   }
 ]
+
 HeadlessPDFOpen.help = 'integration/task/headless-pdf-open'
 
 TaskRegistry.registerTaskHandler('headless-pdf-open', HeadlessPDFOpen)

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

@@ -1,129 +1,34 @@
 import * as fs from 'fs'
 import * as path from 'path'
-import * as ejs from 'ejs'
-import { PDFDocument, rgb, degrees } from 'pdf-lib'
-
 import { TaskRegistry } from '@things-factory/integration-base'
-
-async function HeadlessPDFRenderHeadersAndFooters(pdf, headerTemplate, footerTemplate, watermark, totalPages) {
-  const pages = pdf.getPages()
-
-  pages.forEach((page, index) => {
-    const pageNumber = index + 1
-    const pageWidth = page.getWidth()
-
-    // 헤더와 푸터 렌더링 (페이지 번호 및 총 페이지 수 포함)
-    if (headerTemplate || footerTemplate) {
-      const renderedHeader = headerTemplate
-        ? ejs.render(headerTemplate, {
-            pageNumber,
-            totalPages
-          })
-        : ''
-      const renderedFooter = footerTemplate
-        ? ejs.render(footerTemplate, {
-            pageNumber,
-            totalPages
-          })
-        : ''
-
-      const fontSize = 12 // 폰트 크기 설정
-      const textWidthHeader = fontSize * renderedHeader.length * 0.5
-      const textWidthFooter = fontSize * renderedFooter.length * 0.5
-
-      // Header/Footer 그리기 (가운데 정렬)
-      if (renderedHeader) {
-        page.drawText(renderedHeader, {
-          x: (pageWidth - textWidthHeader) / 2,
-          y: page.getHeight() - 30,
-          size: fontSize,
-          color: rgb(0, 0, 0)
-        })
-      }
-      if (renderedFooter) {
-        page.drawText(renderedFooter, {
-          x: (pageWidth - textWidthFooter) / 2,
-          y: 30,
-          size: fontSize,
-          color: rgb(0, 0, 0)
-        })
-      }
-    }
-
-    // 워터마크 추가
-    if (watermark) {
-      const fontSize = 50
-
-      page.drawText(watermark, {
-        x: pageWidth / 2 - (fontSize * watermark.length) / 4,
-        y: page.getHeight() / 2 - fontSize / 2,
-        size: fontSize,
-        color: rgb(0.75, 0.75, 0.75),
-        rotate: degrees(-45),
-        opacity: 0.5
-      })
-    }
-  })
-}
+import { PDFDocument } from 'pdf-lib'
 
 async function HeadlessPDFSave(step, context) {
   var { params: stepOptions } = step
   var { outputPath } = stepOptions || {}
-  var { domain, data, __headless_pdf } = context
-
-  var { pdf, coverPage, lastPage, watermark, fileName } = __headless_pdf
+  var { __headless_pdf } = context
 
-  const totalPages = pdf.getPages().length
-  await HeadlessPDFRenderHeadersAndFooters(pdf, __headless_pdf.header, __headless_pdf.footer, watermark, totalPages)
-
-  const finalFileName = fileName || `document-${Date.now()}.pdf`
-  const savePath = path.join(outputPath || './attachments', finalFileName)
-
-  if (coverPage) {
-    const coverPageDoc = await PDFDocument.load(coverPage)
-    const [cover] = await pdf.copyPages(coverPageDoc, [0])
-
-    if (watermark) {
-      const fontSize = 50
-      const pageWidth = cover.getWidth()
-      const pageHeight = cover.getHeight()
-
-      cover.drawText(watermark, {
-        x: pageWidth / 2 - (fontSize * watermark.length) / 4,
-        y: pageHeight / 2 - fontSize / 2,
-        size: fontSize,
-        color: rgb(0.75, 0.75, 0.75),
-        rotate: degrees(-45),
-        opacity: 0.5
-      })
-    }
-
-    pdf.insertPage(0, cover)
+  if (!__headless_pdf || !__headless_pdf.pdfDoc) {
+    throw new Error(
+      'No PDF document found. Ensure that headless-pdf-open and headless-pdf-capture tasks are executed before saving.'
+    )
   }
 
-  if (lastPage) {
-    const lastPageDoc = await PDFDocument.load(lastPage)
-    const [last] = await pdf.copyPages(lastPageDoc, [0])
+  const pdfDoc = __headless_pdf.pdfDoc
 
-    if (watermark) {
-      const fontSize = 50
-      const pageWidth = last.getWidth()
-      const pageHeight = last.getHeight()
+  // 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))
+  }
 
-      last.drawText(watermark, {
-        x: pageWidth / 2 - (fontSize * watermark.length) / 4,
-        y: pageHeight / 2 - fontSize / 2,
-        size: fontSize,
-        color: rgb(0.75, 0.75, 0.75),
-        rotate: degrees(-45),
-        opacity: 0.5
-      })
-    }
+  const pdfBytes = await pdfDoc.save()
 
-    pdf.addPage(last)
-  }
+  const finalFileName = __headless_pdf.fileName || `document-${Date.now()}.pdf`
+  const savePath = path.join(outputPath || './attachments', finalFileName)
 
-  const pdfBytes = await pdf.save()
+  // Save the final PDF to the specified path
   fs.writeFileSync(savePath, pdfBytes)
 
   return {
@@ -137,7 +42,8 @@ HeadlessPDFSave.parameterSpec = [
   {
     type: 'string',
     name: 'outputPath',
-    label: 'output-path'
+    label: 'output-path',
+    description: 'The directory path where the PDF should be saved. Defaults to "./attachments".'
   }
 ]
 

package/server/engine/task/index.ts

@@ -1,3 +1,4 @@
 import './headless-pdf-capture'
+import './headless-pdf-capture-board'
 import './headless-pdf-open'
 import './headless-pdf-save'