@things-factory/integration-headless 7.0.38 → 7.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-headless",
-  "version": "7.0.38",
+  "version": "7.0.40",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -22,10 +22,11 @@
     "clean": "npm run clean:server"
   },
   "dependencies": {
+    "@things-factory/board-service": "^7.0.40",
     "@things-factory/integration-base": "^7.0.38",
     "@things-factory/pdf": "^7.0.37",
     "ejs": "^3.1.10",
     "pdf-lib": "^1.17.1"
   },
-  "gitHead": "735942469a12f77ed857ad617b97148d178d162d"
+  "gitHead": "59ccd4873d87a1b38df8387809a68c958076d264"
 }

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

@@ -0,0 +1,363 @@
+import * as ejs from 'ejs'
+import { TaskRegistry } from '@things-factory/integration-base'
+import { ConnectionManager } from '@things-factory/integration-base'
+import { access } from '@things-factory/utils'
+import { BoardFunc } from '@things-factory/board-service'
+import { PDFDocument } from 'pdf-lib'
+
+const PAGE_FORMATS = {
+  A4: { width: 595.28, height: 841.89 },
+  A3: { width: 841.89, height: 1190.55 },
+  Letter: { width: 612, height: 792 },
+  Legal: { width: 612, height: 1008 }
+}
+
+async function HeadlessPDFCaptureBoard(step, context) {
+  var { connection: connectionName, params: stepOptions } = step
+  var {
+    accessor,
+    board,
+    draft,
+    format = 'A4', // Set default value to A4
+    width,
+    height,
+    marginTop = 0,
+    marginBottom = 0,
+    marginLeft = 0,
+    marginRight = 0,
+    scale,
+    printBackground,
+    landscape,
+    preferCSSPageSize
+  } = stepOptions || {}
+  var { domain, data, user, logger, __headless_pdf } = context
+
+  if (!__headless_pdf) {
+    throw new Error('It requires headless-pdf-open to be performed first')
+  }
+
+  if (!board || !board.id) {
+    throw new Error('The board property must be set')
+  }
+
+  var { pdfDoc, header, footer, watermark } = __headless_pdf
+
+  var headlessPool = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+  let browser
+
+  try {
+    browser = await headlessPool.acquire()
+    const page = await browser.newPage()
+
+    const boardInput = access(accessor, data)
+
+    var { model, base } = await BoardFunc.headlessModel({ domain, id: board.id, model }, draft)
+    const [fontsToUse, fontStyles] = await BoardFunc.fonts(domain)
+
+    model.fonts = fontsToUse
+    model.fontStyles = fontStyles
+
+    var { width: boardWidthPx, height: boardHeightPx } = model
+
+    if (preferCSSPageSize) {
+      width = undefined
+      height = undefined
+    } else if (PAGE_FORMATS[format]) {
+      const pageDimensions = PAGE_FORMATS[format]
+      width = pageDimensions.width
+      height = pageDimensions.height
+    }
+
+    if (landscape) {
+      ;[width, height] = [height, width]
+    }
+
+    const contentWidth = width - marginLeft - marginRight
+    const contentHeight = height - marginTop - marginBottom
+
+    const boardWidthPt = (boardWidthPx * 72) / 96
+    const boardHeightPt = (boardHeightPx * 72) / 96
+
+    const widthRatio = contentWidth / boardWidthPt
+    const heightRatio = contentHeight / boardHeightPt
+    const ratio = Math.min(widthRatio, heightRatio)
+
+    const scaledBoardWidthPt = boardWidthPt * ratio
+    const scaledBoardHeightPt = boardHeightPt * ratio
+
+    const offsetX = (contentWidth - scaledBoardWidthPt) / 2 + marginLeft
+    const offsetY = (contentHeight - scaledBoardHeightPt) / 2 + marginBottom
+
+    await page.setViewport({ width: Math.round(boardWidthPx * ratio), height: Math.round(boardHeightPx * ratio) })
+    await page.setRequestInterception(true)
+    await page.setDefaultTimeout(10000)
+
+    page.on('console', async msg => {
+      console.log(`[browser ${msg.type()}] ${msg.text()}`)
+    })
+
+    page.on('requestfailed', request => {
+      console.log('Request failed:', request.url())
+    })
+
+    const protocol = 'http'
+    const host = 'localhost'
+    const port = process.env.PORT ? `:${process.env.PORT}` : ''
+    const path = '/internal-board-service-view'
+    const url = `${protocol}://${host}${port}${path}`
+
+    const token = await user?.sign()
+
+    page.on('request', request => {
+      if (request.url() === url) {
+        request.continue({
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'x-things-factory-domain': domain?.subdomain,
+            Authorization: 'Bearer ' + token
+          },
+          postData: JSON.stringify({
+            model,
+            base
+          })
+        })
+      } else if (request.url().startsWith(`${protocol}://${host}${port}`)) {
+        request.continue({
+          headers: {
+            ...request.headers(),
+            'x-things-factory-domain': domain?.subdomain,
+            Authorization: 'Bearer ' + token
+          }
+        })
+      } else {
+        request.continue()
+      }
+    })
+
+    await page.goto(url)
+
+    await page.evaluate(data => {
+      //@ts-ignore
+      s.data = data
+      return new Promise(resolve => {
+        requestAnimationFrame(() => resolve(0))
+      })
+    }, boardInput)
+
+    const renderTemplateSafely = (template, data) => {
+      try {
+        return ejs.render(template, data)
+      } catch (error) {
+        logger.warn(`Template rendering error: ${error.message}`)
+        return template
+      }
+    }
+
+    header = renderTemplateSafely(header, __headless_pdf)
+    footer = renderTemplateSafely(footer, __headless_pdf)
+
+    // 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'
+            element.style.margin = '0'
+            element.style.padding = '0'
+            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: `${scaledBoardWidthPt}px`,
+      height: `${scaledBoardHeightPt}px`,
+      margin: {
+        top: `${offsetY}px`,
+        right: `${offsetX}px`,
+        bottom: `${offsetY}px`,
+        left: `${offsetX}px`
+      },
+      scale,
+      printBackground,
+      landscape,
+      displayHeaderFooter: false, // Handled via Puppeteer directly
+      preferCSSPageSize
+    }
+
+    const contentBuffer = await page.pdf(pageOptions)
+    const contentPdfDoc = await PDFDocument.load(contentBuffer)
+    const copiedPages = await pdfDoc.copyPages(contentPdfDoc, contentPdfDoc.getPageIndices())
+
+    copiedPages.forEach(page => pdfDoc.addPage(page))
+
+    __headless_pdf.pageCount += copiedPages.length
+
+    await page.close()
+    headlessPool.release(browser)
+
+    return {
+      data: __headless_pdf
+    }
+  } catch (error) {
+    if (browser) {
+      await browser.close()
+    }
+
+    throw error
+  }
+}
+
+HeadlessPDFCaptureBoard.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
+  {
+    type: 'resource-object',
+    name: 'board',
+    label: 'board',
+    property: {
+      queryName: 'boards'
+    }
+  },
+  {
+    type: 'boolean',
+    name: 'draft',
+    label: 'draft',
+    defaultValue: false,
+    description: 'Set whether to get the current working version or the last released version'
+  },
+  {
+    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'
+  }
+]
+
+HeadlessPDFCaptureBoard.help = 'integration/task/headless-pdf-capture-board'
+
+TaskRegistry.registerTaskHandler('headless-pdf-capture-board', HeadlessPDFCaptureBoard)

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

@@ -1,51 +1,110 @@
 import * as ejs from 'ejs'
-import { PDFDocument, rgb, degrees } from 'pdf-lib'
-
 import { TaskRegistry } from '@things-factory/integration-base'
 import { ConnectionManager } from '@things-factory/integration-base'
+import { access } from '@things-factory/utils'
+import { PDFDocument } from 'pdf-lib'
 
 async function HeadlessPDFCapture(step, context) {
   var { connection: connectionName, params: stepOptions } = step
   var {
+    accessor,
     htmlContent,
     format,
     width,
     height,
-    margin,
+    marginTop,
+    marginBottom,
+    marginLeft,
+    marginRight,
     scale,
     printBackground,
     landscape,
-    displayHeaderFooter,
-    headerTemplate,
-    footerTemplate,
     preferCSSPageSize
   } = stepOptions || {}
-  var { domain, data, __headless_pdf } = context
+  var { domain, data, logger, __headless_pdf } = context
 
   if (!__headless_pdf) {
-    throw new Error('it requires headless-pdf-open to be performed first')
+    throw new Error('It requires headless-pdf-open to be performed first')
   }
 
-  var {
-    pdf,
-    header: headerTemplateFromContext,
-    footer: footerTemplateFromContext,
-    watermark,
-    pageCount
-  } = __headless_pdf
+  var { pdfDoc, header, footer, watermark } = __headless_pdf
 
   var headlessPool = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
   let browser
 
   try {
-    // Puppeteer를 사용하여 브라우저와 페이지 인스턴스를 생성
     browser = await headlessPool.acquire()
     const page = await browser.newPage()
 
-    // 설정된 HTML 콘텐츠를 페이지에 설정
-    await page.setContent(htmlContent)
+    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
+      }
+    }
+
+    const renderedHtmlContent = renderTemplateSafely(htmlContent, templateInput)
+    await page.setContent(renderedHtmlContent)
+
+    header = renderTemplateSafely(header, __headless_pdf)
+    footer = renderTemplateSafely(footer, __headless_pdf)
+
+    // 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'
+            element.style.margin = '0'
+            element.style.padding = '0'
+            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 }
+      )
+    }
 
-    // PDF 페이지 생성 옵션 설정
     if (preferCSSPageSize) {
       width = undefined
       height = undefined
@@ -55,73 +114,26 @@ async function HeadlessPDFCapture(step, context) {
       format,
       width,
       height,
-      margin,
+      margin: {
+        top: marginTop,
+        right: marginRight,
+        bottom: marginBottom,
+        left: marginLeft
+      },
       scale,
       printBackground,
       landscape,
-      displayHeaderFooter,
-      headerTemplate: displayHeaderFooter ? headerTemplate : undefined,
-      footerTemplate: displayHeaderFooter ? footerTemplate : undefined,
+      displayHeaderFooter: false, // Handled via Puppeteer directly
       preferCSSPageSize
     }
 
-    // 페이지를 PDF로 변환
-    const pageBuffer = await page.pdf(pageOptions)
-
-    // PDF-lib을 사용하여 PDF를 로드하고 추가 조작
-    const pdfDoc = await PDFDocument.load(pageBuffer)
-    const pages = await pdf.copyPages(pdfDoc, pdfDoc.getPageIndices())
-
-    pages.forEach((newPage, index) => {
-      const currentPageNumber = pageCount + index + 1
-
-      // 헤더와 푸터 렌더링 (페이지 번호 및 총 페이지 수 포함)
-      if (displayHeaderFooter && (headerTemplateFromContext || footerTemplateFromContext)) {
-        const renderedHeader = headerTemplateFromContext
-          ? ejs.render(headerTemplateFromContext, {
-              ...data,
-              pageNumber: currentPageNumber,
-              totalPages: pageCount + pages.length
-            })
-          : ''
-        const renderedFooter = footerTemplateFromContext
-          ? ejs.render(footerTemplateFromContext, {
-              ...data,
-              pageNumber: currentPageNumber,
-              totalPages: pageCount + pages.length
-            })
-          : ''
-
-        // Header/Footer 그리기
-        if (renderedHeader) {
-          newPage.drawText(renderedHeader, { x: 50, y: newPage.getHeight() - 30, size: 12, color: rgb(0, 0, 0) })
-        }
-        if (renderedFooter) {
-          newPage.drawText(renderedFooter, { x: 50, y: 30, size: 12, color: rgb(0, 0, 0) })
-        }
-      }
-
-      // 워터마크 추가
-      if (watermark) {
-        const fontSize = 50
-        const pageWidth = newPage.getWidth()
-        const pageHeight = newPage.getHeight()
-
-        newPage.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 contentBuffer = await page.pdf(pageOptions)
+    const contentPdfDoc = await PDFDocument.load(contentBuffer)
+    const copiedPages = await pdfDoc.copyPages(contentPdfDoc, contentPdfDoc.getPageIndices())
 
-      pdf.addPage(newPage)
-    })
+    copiedPages.forEach(page => pdfDoc.addPage(page))
 
-    // 페이지 카운트 업데이트
-    __headless_pdf.pageCount += pages.length
+    __headless_pdf.pageCount += copiedPages.length
 
     await page.close()
     headlessPool.release(browser)
@@ -139,6 +151,11 @@ async function HeadlessPDFCapture(step, context) {
 }
 
 HeadlessPDFCapture.parameterSpec = [
+  {
+    type: 'scenario-step-input',
+    name: 'accessor',
+    label: 'accessor'
+  },
   {
     type: 'textarea',
     name: 'htmlContent',
@@ -150,6 +167,7 @@ HeadlessPDFCapture.parameterSpec = [
     label: 'page-format',
     property: {
       options: [
+        { display: '', value: '' },
         { display: 'A4', value: 'A4' },
         { display: 'A3', value: 'A3' },
         { display: 'Letter', value: 'Letter' },
@@ -173,21 +191,37 @@ HeadlessPDFCapture.parameterSpec = [
     description: 'Specify the height of the page (e.g., "11in", "29.7cm", "800px")'
   },
   {
-    type: 'json',
-    name: 'margin',
-    label: 'page-margins',
-    fields: [
-      { type: 'string', name: 'top', label: 'Top Margin', description: 'Top margin (e.g., "1in")' },
-      { type: 'string', name: 'right', label: 'Right Margin', description: 'Right margin (e.g., "1in")' },
-      { type: 'string', name: 'bottom', label: 'Bottom Margin', description: 'Bottom margin (e.g., "1in")' },
-      { type: 'string', name: 'left', label: 'Left Margin', description: 'Left margin (e.g., "1in")' }
-    ],
-    description: 'Set the margins for the page'
+    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: 'scale',
+    label: 'page-scale',
     defaultValue: 1,
     description: 'Set the scale of the page content (default is 1)'
   },
@@ -205,13 +239,6 @@ HeadlessPDFCapture.parameterSpec = [
     defaultValue: false,
     description: 'Print the PDF in landscape orientation'
   },
-  {
-    type: 'boolean',
-    name: 'displayHeaderFooter',
-    label: 'display-header/footer',
-    defaultValue: false,
-    description: 'Display header and footer in the PDF'
-  },
   {
     type: 'boolean',
     name: 'preferCSSPageSize',