@things-factory/integration-headless 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,98 @@
+import { PDFDocument } from 'pdf-lib'
+import { TaskRegistry } from '@things-factory/integration-base'
+import { access } from '@things-factory/utils'
+import { PDFCaptureUtil, getCommonParameterSpec } from './pdf-capture-util'
+
+async function HeadlessPDFOpen(step, context) {
+  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()
+
+  try {
+    const fileNameEncoded = fileName ? new TextEncoder().encode(access(fileName, data)) : undefined
+
+    const pdfInfo = {
+      pdfDoc,
+      watermark,
+      fileName: fileNameEncoded,
+      pageCount: 0
+    } as any
+    context.__headless_pdf = pdfInfo
+
+    var pdfUtil = new PDFCaptureUtil(context)
+    await pdfUtil.initBrowser(connectionName)
+
+    const templateInput = access(accessor, data)
+
+    // Convert Cover Page to PDF and add it to the document (if provided)
+    if (coverPage) {
+      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 = pdfUtil.renderTemplate(lastPage, templateInput)
+      lastPageBuffer = await pdfUtil.generateLastPageBuffer(stepOptions, renderedLastPage)
+    }
+
+    pdfInfo.lastPageBuffer = lastPageBuffer
+    pdfInfo.pageCount = pdfDoc.getPageCount()
+    pdfInfo.header = header
+    pdfInfo.footer = footer
+
+    return {
+      data: pdfInfo
+    }
+  } catch (error) {
+    throw error
+  } finally {
+    await pdfUtil?.closeBrowser()
+  }
+}
+
+HeadlessPDFOpen.parameterSpec = [
+  ...getCommonParameterSpec(),
+  {
+    type: 'textarea',
+    name: 'coverPage',
+    label: 'pdf-cover-page'
+  },
+  {
+    type: 'textarea',
+    name: 'lastPage',
+    label: 'pdf-last-page'
+  },
+  {
+    type: 'string',
+    name: 'header',
+    label: 'header',
+    placeholder: 'Page <%= pageNumber %> of <%= totalPages %>'
+  },
+  {
+    type: 'string',
+    name: 'footer',
+    label: 'footer',
+    placeholder: 'Page <%= pageNumber %> of <%= totalPages %>'
+  },
+  {
+    type: 'string',
+    name: 'watermark',
+    label: 'watermark'
+  },
+  {
+    type: 'string',
+    name: 'fileName',
+    label: 'filename'
+  }
+]
+
+HeadlessPDFOpen.help = 'integration/task/headless-pdf-open'
+
+TaskRegistry.registerTaskHandler('headless-pdf-open', HeadlessPDFOpen)

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

@@ -0,0 +1,88 @@
+import { PDFDocument } from 'pdf-lib'
+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) {
+  const { domain, user, __headless_pdf } = context
+
+  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.'
+    )
+  }
+
+  const pdfDoc = __headless_pdf.pdfDoc
+
+  // Add last page if it exists
+  if (__headless_pdf.lastPageBuffer) {
+    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)
+
+  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))
+}
+
+function generateFileName(fileName) {
+  return fileName || `document-${Date.now()}.pdf`
+}
+
+async function savePDFToFile(pdfBytes, finalFileName, domain, user) {
+  return await createAttachment(
+    null,
+    {
+      attachment: {
+        file: {
+          createReadStream: () =>
+            new Readable({
+              read() {
+                this.push(pdfBytes)
+                this.push(null)
+              }
+            }),
+          filename: finalFileName,
+          mimetype: 'application/pdf',
+          encoding: 'binary'
+        },
+        refType: 'headless-pdf-save',
+        refBy: 'pdf-published'
+      }
+    },
+    {
+      state: { domain, user }
+    }
+  )
+}
+
+async function getAttachmentDetails(attachmentId) {
+  return await getRepository(Attachment).findOne({
+    where: { id: attachmentId }
+  })
+}
+
+HeadlessPDFSave.parameterSpec = []
+
+HeadlessPDFSave.help = 'integration/task/headless-pdf-save'
+
+TaskRegistry.registerTaskHandler('headless-pdf-save', HeadlessPDFSave)

package/server/engine/task/index.ts

@@ -0,0 +1,9 @@
+import './headless-pdf-capture'
+import './headless-pdf-capture-markdown'
+import './headless-pdf-capture-board'
+import './headless-pdf-open'
+import './headless-pdf-save'
+import './pdf-capture-util'
+
+export * from './pdf-capture-util'
+export * from './headless-pdf-capture-board'

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

@@ -0,0 +1,331 @@
+import * as ejs from 'ejs'
+import { ConnectionManager } from '@things-factory/integration-base'
+import { PDFDocument } from 'pdf-lib'
+import { Browser, Page } from 'puppeteer'
+import { Logger } from 'winston'
+
+interface StepOptions {
+  format?: string
+  width?: string
+  height?: string
+  marginTop?: string
+  marginBottom?: string
+  marginLeft?: string
+  marginRight?: string
+  scale?: number
+  printBackground?: boolean
+  landscape?: boolean
+  preferCSSPageSize?: boolean
+}
+
+interface PDFContext {
+  domain: any
+  data: any
+  logger: Logger
+  __headless_pdf: any
+}
+
+export class PDFCaptureUtil {
+  private context: PDFContext
+  private headlessPool: any
+
+  public browser: Browser | null = null
+
+  constructor(context: PDFContext) {
+    this.context = context
+  }
+
+  async initBrowser(connectionName: string) {
+    const { domain } = this.context
+    this.headlessPool = ConnectionManager.getConnectionInstanceByName(domain, connectionName)
+    this.browser = await this.headlessPool.acquire()
+  }
+
+  async closeBrowser() {
+    if (this.browser) {
+      await this.browser.close()
+      this.headlessPool.release(this.browser)
+    }
+  }
+
+  renderTemplate(template: string, data: any): string {
+    const { logger } = this.context
+    try {
+      return ejs.render(template, data)
+    } catch (error) {
+      logger.warn(`Template rendering error: ${error.message}`)
+      return template
+    }
+  }
+
+  async generatePDFContent(page: Page, pageOptions: any): Promise<PDFDocument> {
+    const contentBuffer = await page.pdf(pageOptions)
+    const contentPdfDoc = await PDFDocument.load(contentBuffer)
+    return contentPdfDoc
+  }
+
+  async appendPDFContentToDocument(pdfDoc: PDFDocument, contentPdfDoc: PDFDocument) {
+    const copiedPages = await pdfDoc.copyPages(contentPdfDoc, contentPdfDoc.getPageIndices())
+    copiedPages.forEach(page => pdfDoc.addPage(page))
+    this.context.__headless_pdf.pageCount += copiedPages.length
+  }
+
+  async processPageAndGeneratePDF(stepOptions: StepOptions, htmlContent: string, page?: Page) {
+    if (!this.browser) throw new Error('Browser not initialized. Call initBrowser() first.')
+
+    if (!page) {
+      page = page || (await this.browser.newPage())
+    }
+
+    if (htmlContent) {
+      // 페이지 컨텐츠 설정
+      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, data: __headless_pdf })
+    }
+
+    const pageOptions = this.buildPageOptions(stepOptions)
+    const contentPdfDoc = await this.generatePDFContent(page, pageOptions)
+    await this.appendPDFContentToDocument(__headless_pdf.pdfDoc, contentPdfDoc)
+    await page.close()
+  }
+
+  buildPageOptions({
+    format,
+    width,
+    height,
+    marginTop,
+    marginBottom,
+    marginLeft,
+    marginRight,
+    scale,
+    printBackground,
+    landscape,
+    preferCSSPageSize
+  }: StepOptions): any {
+    if (preferCSSPageSize) {
+      width = undefined
+      height = undefined
+    }
+
+    return {
+      format,
+      width,
+      height,
+      margin: {
+        top: marginTop,
+        right: marginRight,
+        bottom: marginBottom,
+        left: marginLeft
+      },
+      scale,
+      printBackground,
+      landscape,
+      displayHeaderFooter: false,
+      preferCSSPageSize
+    }
+  }
+
+  async applyHeaderFooterWatermark(
+    page: Page,
+    {
+      header,
+      footer,
+      watermark,
+      landscape,
+      data
+    }: { header: string; footer: string; watermark: string; landscape: boolean; data: any }
+  ) {
+    await page.evaluate(
+      ({ header, footer, watermark, landscape, data }) => {
+        const setPositioning = (element: HTMLElement, position: 'header' | 'footer') => {
+          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'
+          element.style.zIndex = '1000'
+
+          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 = landscape ? '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: 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 { __headless_pdf } = this.context
+    const { header, footer, watermark, landscape } = __headless_pdf
+
+    if (header || footer || watermark) {
+      await this.applyHeaderFooterWatermark(page, { header, footer, watermark, landscape, data: __headless_pdf })
+    }
+
+    // 페이지 옵션 설정
+    const pageOptions = this.buildPageOptions(stepOptions)
+
+    // PDF를 생성하고 버퍼를 반환합니다.
+    const lastPageBuffer = await page.pdf(pageOptions)
+
+    // 페이지 닫기
+    await page.close()
+
+    return lastPageBuffer
+  }
+}
+
+export function getCommonParameterSpec() {
+  return [
+    {
+      type: 'scenario-step-input',
+      name: 'accessor',
+      label: 'accessor'
+    },
+    {
+      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/index.ts

@@ -0,0 +1,3 @@
+import './engine'
+
+export * from './engine/task'

package/server/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig-base.json",
+  "compilerOptions": {
+    "strict": false,
+    "module": "commonjs",
+    "outDir": "../dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./**/*"]
+}