@things-factory/pdf 8.0.0-beta.8 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/pdf",
-  "version": "8.0.0-beta.8",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -26,12 +26,12 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.8",
-    "@things-factory/utils": "^8.0.0-beta.4",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/utils": "^8.0.0",
     "await-spawn": "^4.0.1",
     "ejs": "^3.1.10",
     "handlebars": "^4.7.8",
     "pdf-lib": "^1.17.1"
   },
-  "gitHead": "bf5206511b2d84dfb95edc3dae7f54f6cbb9bcca"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/controller/pdf-service.ts

@@ -0,0 +1,35 @@
+import * as ejs from 'ejs'
+import { PDFDocument } from 'pdf-lib'
+import { PDFTemplate } from '../service/pdf-template/pdf-template'
+
+export class PdfService {
+  async generatePdf(template: PDFTemplate, data: any): Promise<Buffer> {
+    const pdfDoc = await PDFDocument.create()
+
+    // 템플릿 렌더링
+    const renderedContent = await ejs.render(template.content_template || '', data)
+
+    // PDF 생성
+    const page = pdfDoc.addPage()
+    const { width, height } = page.getSize()
+    page.drawText(renderedContent, {
+      x: 50,
+      y: height - 50,
+      size: 12
+    })
+
+    // 추가적으로 header, footer, cover 등의 렌더링 및 PDF 구성 가능
+    if (template.header_template) {
+      const renderedHeader = await ejs.render(template.header_template, data)
+      // Header 처리 로직
+    }
+
+    if (template.footer_template) {
+      const renderedFooter = await ejs.render(template.footer_template, data)
+      // Footer 처리 로직
+    }
+
+    const pdfBytes = await pdfDoc.save()
+    return Buffer.from(pdfBytes)
+  }
+}

package/server/index.ts

@@ -0,0 +1,3 @@
+export * from './service'
+
+import './routes'

package/server/routers/pdf-private-router.ts

@@ -0,0 +1,85 @@
+import Router from 'koa-router'
+import * as fs from 'fs'
+import * as path from 'path'
+import send from 'koa-send'
+
+import { PDFRelease } from '../service/pdf-release/pdf-release'
+import { PDFTemplate } from '../service/pdf-template/pdf-template'
+import { PdfService } from '../controller/pdf-service'
+
+const PDF_STORAGE_PATH = '/path/to/pdf/storage' // 실제 파일 저장 경로
+const PDF_BASE_URL = 'https://yourdomain.com/pdf/' // 파일 접근 URL의 기본 경로
+
+const pdfService = new PdfService()
+
+export const pdfPrivateRouter = new Router()
+
+function parseQuery(query) {
+  for (const key in query) {
+    if (query.hasOwnProperty(key)) {
+      try {
+        query[key] = JSON.parse(query[key])
+      } catch (error) {
+        // do nothing
+      }
+    }
+  }
+
+  return query
+}
+
+// PDF 생성 및 저장 라우터
+pdfPrivateRouter.post('/generate-pdf', async ctx => {
+  const { templateId, data } = ctx.request.body
+  const { domain, user, tx } = ctx.state
+
+  const templateRepository = tx.getRepository(PDFTemplate)
+  const releaseRepository = tx.getRepository(PDFRelease)
+
+  const template = await templateRepository.findOne(templateId)
+  if (!template) {
+    ctx.throw(404, 'PDF Template not found')
+  }
+
+  // EJS 템플릿을 사용하여 PDF 생성
+  const pdfBuffer = await pdfService.generatePdf(template, data)
+
+  // 파일 저장 경로 및 URL 생성
+  const fileName = `${template.name}-${Date.now()}.pdf`
+  const filePath = path.join(PDF_STORAGE_PATH, fileName)
+  const fileUrl = `${PDF_BASE_URL}${fileName}`
+
+  // 파일 저장
+  fs.writeFileSync(filePath, pdfBuffer)
+
+  // 발행 이력 기록
+  const release = releaseRepository.create({
+    template,
+    filePath,
+    fileUrl,
+    state: 'published',
+    releasedBy: user,
+    domain
+  })
+
+  await releaseRepository.save(release)
+
+  ctx.body = release
+})
+
+// PDF 다운로드 라우터
+pdfPrivateRouter.get('/download-pdf/:id', async ctx => {
+  const { id } = ctx.params
+  const { tx } = ctx.state
+
+  const releaseRepository = tx.getRepository(PDFRelease)
+  const pdfRelease = await releaseRepository.findOne(id)
+
+  if (!pdfRelease || !pdfRelease.filePath || !fs.existsSync(pdfRelease.filePath)) {
+    ctx.throw(404, 'PDF file not found')
+  }
+
+  // PDF 파일을 클라이언트에 전송
+  ctx.attachment(path.basename(pdfRelease.filePath))
+  await send(ctx, pdfRelease.filePath, { root: '/' })
+})

package/server/routers/pdf-public-router.ts

@@ -0,0 +1,80 @@
+import await_spawn from 'await-spawn'
+import { promises as fs } from 'fs'
+import Router from 'koa-router'
+import path from 'path'
+import { withTempDir } from '@things-factory/utils'
+
+export const pdfPublicRouter = new Router()
+
+/* to-png */
+pdfPublicRouter.get('/to-png', async (context, next) => {
+  const { url } = context.query
+
+  const images = await withTempDir(async tmpDir => {
+    const curl = await_spawn('curl', ['-s', url])
+
+    await await_spawn('gs', ['-q', '-sDEVICE=png16m', '-o', `${tmpDir}/%d.png`, '-r300', '-'], {
+      stdio: [curl.child.stdout, 'pipe', 'pipe']
+    })
+
+    const files = await fs.readdir(tmpDir)
+    return Promise.all(
+      files
+        .sort(new Intl.Collator(undefined, { numeric: true }).compare)
+        .map(filename => fs.readFile(path.join(tmpDir, filename)))
+    )
+  })
+
+  /* TODO make it possible to return multiple images */
+  context.type = 'image/png'
+  context.body = images[0]
+})
+
+/* merge-pdf */
+const mergePDFfiles = async urls => {
+  return await withTempDir(async tmpdir => {
+    const sources = typeof urls == 'string' ? [urls] : urls
+    const output = path.join(tmpdir, 'output.pdf')
+    const inputs = sources.map((source, idx) => path.join(tmpdir, `${idx}.pdf`))
+
+    try {
+      await Promise.all(
+        sources.map((source, idx) => await_spawn('curl', ['-sSL', source, '-o', path.join(tmpdir, `${idx}.pdf`)]))
+      )
+
+      await await_spawn('gs', [
+        '-q',
+        '-sDEVICE=pdfwrite',
+        '-dAutoRotatePages=/None',
+        '-dNOPAUSE',
+        '-dBATCH',
+        '-dSAFER',
+        `-sOutputFile=${output}`,
+        ...inputs
+      ])
+
+      return await fs.readFile(output)
+    } catch (e) {
+      console.error('mergePDFfiles', 'error', e)
+    }
+  })
+}
+
+pdfPublicRouter.get('/merge', async (context, next) => {
+  const searchParams = new URLSearchParams(context.querystring)
+  const urls = searchParams.getAll('urls')
+
+  const pdf = await mergePDFfiles(urls)
+
+  context.type = 'application/pdf'
+  context.body = pdf
+})
+
+pdfPublicRouter.post('/merge', async (context, next) => {
+  const { urls } = context.request.body
+
+  const pdf = await mergePDFfiles(urls)
+
+  context.type = 'application/pdf'
+  context.body = pdf
+})

package/server/routers/proxy-router.ts

@@ -0,0 +1,9 @@
+import Router from 'koa-router'
+import request from 'request'
+
+export const proxyRouter = new Router()
+
+proxyRouter.get('/', async (context, next) => {
+  const { url } = context.query
+  context.body = context.req.pipe(request(url))
+})

package/server/routes.ts

@@ -0,0 +1,19 @@
+import { config } from '@things-factory/env'
+import { pdfPublicRouter } from './routers/pdf-public-router'
+import { pdfPrivateRouter } from './routers/pdf-private-router'
+import { proxyRouter } from './routers/proxy-router'
+
+const isPathBaseDomain = !config.get('subdomain') && !config.get('useVirtualHostBasedDomain')
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  globalPublicRouter.use('/pdf', pdfPublicRouter.routes(), pdfPublicRouter.allowedMethods())
+  globalPublicRouter.use('/proxy', proxyRouter.routes(), proxyRouter.allowedMethods())
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  if (isPathBaseDomain) {
+    domainPrivateRouter.use('/domain/:domain', pdfPrivateRouter.routes(), pdfPrivateRouter.allowedMethods())
+  } else {
+    domainPrivateRouter.use('', pdfPrivateRouter.routes(), pdfPrivateRouter.allowedMethods())
+  }
+})

package/server/service/index.ts

@@ -0,0 +1,38 @@
+/* EXPORT ENTITY TYPES */
+export * from './pdf-release/pdf-release'
+export * from './pdf-template/pdf-template'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as PdfReleaseEntities,
+  resolvers as PdfReleaseResolvers,
+  subscribers as PdfReleaseSubscribers
+} from './pdf-release'
+import {
+  entities as PDFTemplateEntities,
+  resolvers as PDFTemplateResolvers,
+  subscribers as PDFTemplateSubscribers
+} from './pdf-template'
+
+export const entities = [
+  /* ENTITIES */
+  ...PdfReleaseEntities,
+  ...PdfReleaseEntities,
+  ...PDFTemplateEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...PdfReleaseSubscribers,
+  ...PdfReleaseSubscribers,
+  ...PDFTemplateSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...PdfReleaseResolvers,
+    ...PdfReleaseResolvers,
+    ...PDFTemplateResolvers
+  ]
+}

package/server/service/pdf-generate/pdf-generate-resolver.ts

@@ -0,0 +1,81 @@
+import { Resolver, Mutation, Arg, Ctx, Query } from 'type-graphql'
+import * as fs from 'fs'
+import * as path from 'path'
+
+import { PDFRelease, PDFReleaseStatus } from '../pdf-release/pdf-release'
+import { PDFTemplate } from '../pdf-template/pdf-template'
+import { PdfService } from '../../controller/pdf-service'
+import send from 'koa-send'
+
+const PDF_STORAGE_PATH = '/path/to/pdf/storage' // 실제 파일 저장 경로
+const PDF_BASE_URL = 'https://yourdomain.com/pdf/' // 파일 접근 URL의 기본 경로
+
+@Resolver()
+export class PDFGenerateResolver {
+  private pdfService = new PdfService()
+
+  @Mutation(() => PDFRelease)
+  async generatePDF(
+    @Arg('templateId') templateId: string,
+    @Arg('data') data: any,
+    @Ctx() ctx: ResolverContext
+  ): Promise<PDFRelease> {
+    const { domain, user, tx } = ctx.state
+    const templateRepository = tx.getRepository(PDFTemplate)
+    const releaseRepository = tx.getRepository(PDFRelease)
+
+    const template = await templateRepository.findOne({ where: { id: templateId, domain: { id: domain.id } } })
+    if (!template) {
+      throw new Error('PDF Template not found')
+    }
+
+    var state: PDFReleaseStatus = PDFReleaseStatus.published
+
+    try {
+      const pdfBuffer = await this.pdfService.generatePdf(template, data)
+
+      const fileName = `${template.name}-${Date.now()}.pdf`
+      const filePath = path.join(PDF_STORAGE_PATH, fileName)
+      const fileUrl = `${PDF_BASE_URL}${fileName}`
+
+      fs.writeFileSync(filePath, pdfBuffer)
+
+      return releaseRepository.save({
+        template,
+        filePath,
+        fileUrl,
+        state,
+        creator: user,
+        updater: user,
+        domain
+      })
+    } catch (error) {
+      state = PDFReleaseStatus.failed
+      return releaseRepository.save({
+        template,
+        state,
+        creator: user,
+        updater: user,
+        domain
+      })
+    }
+  }
+
+  @Query(() => String, { description: 'Download the generated PDF file' })
+  async downloadPDF(@Arg('id') id: string, @Ctx() ctx: ResolverContext): Promise<string> {
+    const { domain, user, tx } = ctx.state
+
+    const releaseRepository = tx.getRepository(PDFRelease)
+    const pdfRelease = await releaseRepository.findOne({ where: { id, domain: { id: domain.id } } })
+
+    if (!pdfRelease || !pdfRelease.filePath || !fs.existsSync(pdfRelease.filePath)) {
+      throw new Error('PDF file not found')
+    }
+
+    // PDF 파일을 클라이언트에 전송
+    ctx.attachment(path.basename(pdfRelease.filePath))
+    await send(ctx, pdfRelease.filePath, { root: '/' })
+
+    return 'Download started'
+  }
+}

package/server/service/pdf-release/index.ts

@@ -0,0 +1,7 @@
+import { PDFRelease } from './pdf-release'
+import { PDFReleaseQuery } from './pdf-release-query'
+import { PDFReleaseMutation } from './pdf-release-mutation'
+
+export const entities = [PDFRelease]
+export const resolvers = [PDFReleaseQuery, PDFReleaseMutation]
+export const subscribers = []

package/server/service/pdf-release/pdf-release-mutation.ts

@@ -0,0 +1,138 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { PDFRelease } from './pdf-release'
+import { NewPDFRelease, PDFReleasePatch } from './pdf-release-type'
+
+@Resolver(PDFRelease)
+export class PDFReleaseMutation {
+  @Directive('@transaction')
+  @Mutation(returns => PDFRelease, { description: 'To create new PDFRelease' })
+  async createPDFRelease(
+    @Arg('pdfRelease') pdfRelease: NewPDFRelease,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFRelease> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(PDFRelease).save({
+      ...pdfRelease,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => PDFRelease, { description: 'To modify PDFRelease information' })
+  async updatePDFRelease(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PDFReleasePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFRelease> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(PDFRelease)
+    const pdfRelease = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...pdfRelease,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [PDFRelease], { description: "To modify multiple PDFReleases' information" })
+  async updateMultiplePDFRelease(
+    @Arg('patches', type => [PDFReleasePatch]) patches: PDFReleasePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<PDFRelease[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const pdfReleaseRepo = tx.getRepository(PDFRelease)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await pdfReleaseRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const pdfRelease = await pdfReleaseRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await pdfReleaseRepo.save({
+          ...pdfRelease,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete PDFRelease' })
+  async deletePDFRelease(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFRelease).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple PDFReleases' })
+  async deletePDFReleases(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFRelease).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple PDFReleases' })
+  async importPDFReleases(
+    @Arg('pdfReleases', type => [PDFReleasePatch]) pdfReleases: PDFReleasePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      pdfReleases.map(async (pdfRelease: PDFReleasePatch) => {
+        const createdPDFRelease: PDFRelease = await tx.getRepository(PDFRelease).save({ domain, ...pdfRelease })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/pdf-release/pdf-release-query.ts

@@ -0,0 +1,51 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { PDFRelease } from './pdf-release'
+import { PDFReleaseList } from './pdf-release-type'
+
+@Resolver(PDFRelease)
+export class PDFReleaseQuery {
+  @Query(returns => PDFRelease!, { nullable: true, description: 'To fetch a PDFRelease' })
+  async pdfRelease(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PDFRelease> {
+    const { domain } = context.state
+
+    return await getRepository(PDFRelease).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => PDFReleaseList, { description: 'To fetch multiple PDFReleases' })
+  async pdfReleases(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFReleaseList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(PDFRelease),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() pdfRelease: PDFRelease): Promise<Domain> {
+    return pdfRelease.domainId && (await getRepository(Domain).findOneBy({ id: pdfRelease.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() pdfRelease: PDFRelease): Promise<User> {
+    return pdfRelease.updaterId && (await getRepository(User).findOneBy({ id: pdfRelease.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() pdfRelease: PDFRelease): Promise<User> {
+    return pdfRelease.creatorId && (await getRepository(User).findOneBy({ id: pdfRelease.creatorId }))
+  }
+}

package/server/service/pdf-release/pdf-release-type.ts

@@ -0,0 +1,55 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { PDFRelease, PDFReleaseStatus } from './pdf-release'
+
+@InputType()
+export class NewPDFRelease {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFReleaseStatus, { nullable: true })
+  state?: PDFReleaseStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class PDFReleasePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFReleaseStatus, { nullable: true })
+  state?: PDFReleaseStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class PDFReleaseList {
+  @Field(type => [PDFRelease])
+  items: PDFRelease[]
+
+  @Field(type => Int)
+  total: number
+}