@things-factory/pdf 7.0.36 → 7.0.43

package/helps/pdf/pdf-release.md

@@ -0,0 +1,160 @@
+# PdfRelease
+
+Paragraphs are separated by a blank line.
+
+2nd paragraph. _Italic_, **bold**, and `monospace`. Itemized lists
+look like:
+
+- this one
+- that one
+- the other one
+
+Note that --- not considering the asterisk --- the actual text
+content starts at 4-columns in.
+
+> Block quotes are
+> written like so.
+>
+> They can span multiple paragraphs,
+> if you like.
+
+Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all
+in chapters 12--14"). Three dots ... will be converted to an ellipsis.
+Unicode is supported. ☺
+
+## An h2 header
+
+Here's a numbered list:
+
+1. first item
+2. second item
+3. third item
+
+Note again how the actual text starts at 4 columns in (4 characters
+from the left side). Here's a code sample:
+
+# Let me re-iterate ...
+
+for i in 1 .. 10 { do-something(i) }
+
+As you probably guessed, indented 4 spaces. By the way, instead of
+indenting the block, you can use delimited blocks, if you like:
+
+```
+define foobar() {
+print "Welcome to flavor country!";
+}
+```
+
+(which makes copying & pasting easier). You can optionally mark the
+delimited block for Pandoc to syntax highlight it:
+
+```python
+import time
+# Quick, count to ten!
+for i in range(10):
+# (but not *too* quick)
+time.sleep(0.5)
+print(i)
+```
+
+### An h3 header
+
+Now a nested list:
+
+1. First, get these ingredients:
+
+- carrots
+- celery
+- lentils
+
+2. Boil some water.
+
+3. Dump everything in the pot and follow
+   this algorithm:
+
+find wooden spoon
+uncover pot
+stir
+cover pot
+balance wooden spoon precariously on pot handle
+wait 10 minutes
+goto first step (or shut off burner when done)
+
+Do not bump wooden spoon or it will fall.
+
+Notice again how text always lines up on 4-space indents (including
+that last line which continues item 3 above).
+
+Here's a link to [a website](http://foo.bar), to a [local
+doc](local-doc.html), and to a [section heading in the current
+doc](#an-h2-header). Here's a footnote [^1].
+
+[^1]: Some footnote text.
+
+Tables can look like this:
+
+Name Size Material Color
+
+---
+
+All Business 9 leather brown
+Roundabout 10 hemp canvas natural
+Cinderella 11 glass transparent
+
+Table: Shoes sizes, materials, and colors.
+
+(The above is the caption for the table.) Pandoc also supports
+multi-line tables:
+
+---
+
+Keyword Text
+
+---
+
+red Sunsets, apples, and
+other red or reddish
+things.
+
+green Leaves, grass, frogs
+and other things it's
+not easy being.
+
+---
+
+A horizontal rule follows.
+
+---
+
+Here's a definition list:
+
+apples
+: Good for making applesauce.
+
+oranges
+: Citrus!
+
+tomatoes
+: There's no "e" in tomatoe.
+
+Again, text is indented 4 spaces. (Put a blank line between each
+term and its definition to spread things out more.)
+
+Here's a "line block" (note how whitespace is honored):
+
+| Line one
+| Line too
+| Line tree
+
+and images can be specified like so:
+
+![example image](example-image.jpg 'An exemplary image')
+
+Inline math equation: $\omega = d\phi / dt$. Display
+math should get its own line like so:
+
+$$I = \int \rho R^{2} dV$$
+
+And note that you can backslash-escape any punctuation characters
+which you wish to be displayed literally, ex.: \`foo\`, \*bar\*, etc.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/pdf",
-  "version": "7.0.36",
+  "version": "7.0.43",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -26,10 +26,12 @@
     "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^7.0.33",
+    "@things-factory/auth-base": "^7.0.43",
     "@things-factory/utils": "^7.0.33",
     "await-spawn": "^4.0.1",
-    "handlebars": "^4.7.8"
+    "ejs": "^3.1.10",
+    "handlebars": "^4.7.8",
+    "pdf-lib": "^1.17.1"
   },
-  "gitHead": "f9ac274d234e8ba1d67a994953bc63e4ab758b79"
+  "gitHead": "669cf13dccf67bd45260d8f69d919bc1d72c1ce0"
 }

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/routers/pdf-private-router.ts

@@ -1,4 +1,16 @@
 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()
 
@@ -16,9 +28,58 @@ function parseQuery(query) {
   return query
 }
 
-pdfPrivateRouter.post('/pdf-download', async (context, next) => {
-  let { id, model, base } = context.request.body
-  const data = parseQuery({ ...context.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')
+  }
 
-  await context.render('pdf-download', { id, model, data, base })
+  // PDF 파일을 클라이언트에 전송
+  ctx.attachment(path.basename(pdfRelease.filePath))
+  await send(ctx, pdfRelease.filePath, { root: '/' })
 })

package/server/service/index.ts

@@ -1,7 +1,13 @@
 /* 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,
@@ -10,17 +16,23 @@ import {
 
 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
+}