@things-factory/pdf 7.0.33 → 7.0.36

package/helps/pdf/pdf-template.md

@@ -0,0 +1,160 @@
+# PdfTemplate
+
+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,7 +1,8 @@
 {
   "name": "@things-factory/pdf",
-  "version": "7.0.33",
+  "version": "7.0.36",
   "main": "dist-server/index.js",
+  "browser": "dist-client/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
   "description": "Module that provide services for merging pdf files and extracting image from pdf.",
@@ -16,15 +17,19 @@
     "directory": "packages/pdf"
   },
   "scripts": {
-    "build": "tsc --p tsconfig.json",
-    "build:server": "npm run clean:server && tsc",
-    "clean:server": "rm -rf dist-server",
-    "clean": "npm run clean:server",
-    "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
+    "build": "npm run build:server && npm run build:client",
+    "copy:files": "copyfiles -e \"./client/**/*.{ts,js,json}\" -u 1 \"./client/**/*\" dist-client",
+    "build:client": "npm run copy:files && npx tsc --p ./client/tsconfig.json",
+    "build:server": "npx tsc --p ./server/tsconfig.json",
+    "clean:client": "npx rimraf dist-client",
+    "clean:server": "npx rimraf dist-server",
+    "clean": "npm run clean:server && npm run clean:client"
   },
   "dependencies": {
+    "@things-factory/auth-base": "^7.0.33",
     "@things-factory/utils": "^7.0.33",
-    "await-spawn": "^4.0.1"
+    "await-spawn": "^4.0.1",
+    "handlebars": "^4.7.8"
   },
-  "gitHead": "d8ce7eb155cf54e1c8aa9dca34ca7872b0a0c804"
+  "gitHead": "f9ac274d234e8ba1d67a994953bc63e4ab758b79"
 }

package/server/index.ts

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

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

@@ -0,0 +1,24 @@
+import Router from 'koa-router'
+
+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
+}
+
+pdfPrivateRouter.post('/pdf-download', async (context, next) => {
+  let { id, model, base } = context.request.body
+  const data = parseQuery({ ...context.query })
+
+  await context.render('pdf-download', { id, model, data, base })
+})

package/server/routers/{pdf-router.ts → pdf-public-router.ts}

@@ -4,10 +4,10 @@ import Router from 'koa-router'
 import path from 'path'
 import { withTempDir } from '@things-factory/utils'
 
-export const pdfRouter = new Router()
+export const pdfPublicRouter = new Router()
 
 /* to-png */
-pdfRouter.get('/to-png', async (context, next) => {
+pdfPublicRouter.get('/to-png', async (context, next) => {
   const { url } = context.query
 
   const images = await withTempDir(async tmpDir => {
@@ -60,7 +60,7 @@ const mergePDFfiles = async urls => {
   })
 }
 
-pdfRouter.get('/merge', async (context, next) => {
+pdfPublicRouter.get('/merge', async (context, next) => {
   const searchParams = new URLSearchParams(context.querystring)
   const urls = searchParams.getAll('urls')
 
@@ -70,7 +70,7 @@ pdfRouter.get('/merge', async (context, next) => {
   context.body = pdf
 })
 
-pdfRouter.post('/merge', async (context, next) => {
+pdfPublicRouter.post('/merge', async (context, next) => {
   const { urls } = context.request.body
 
   const pdf = await mergePDFfiles(urls)

package/server/routes.ts

@@ -1,7 +1,19 @@
-import { pdfRouter } from './routers/pdf-router'
+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', pdfRouter.routes(), pdfRouter.allowedMethods())
+  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,26 @@
+/* EXPORT ENTITY TYPES */
+export * from './pdf-template/pdf-template'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as PDFTemplateEntities,
+  resolvers as PDFTemplateResolvers,
+  subscribers as PDFTemplateSubscribers
+} from './pdf-template'
+
+export const entities = [
+  /* ENTITIES */
+  ...PDFTemplateEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...PDFTemplateSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...PDFTemplateResolvers
+  ]
+}

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

@@ -0,0 +1,7 @@
+import { PDFTemplate } from './pdf-template'
+import { PDFTemplateQuery } from './pdf-template-query'
+import { PDFTemplateMutation } from './pdf-template-mutation'
+
+export const entities = [PDFTemplate]
+export const resolvers = [PDFTemplateQuery, PDFTemplateMutation]
+export const subscribers = []

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

@@ -0,0 +1,138 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { PDFTemplate } from './pdf-template'
+import { NewPDFTemplate, PDFTemplatePatch } from './pdf-template-type'
+
+@Resolver(PDFTemplate)
+export class PDFTemplateMutation {
+  @Directive('@transaction')
+  @Mutation(returns => PDFTemplate, { description: 'To create new PDFTemplate' })
+  async createPDFTemplate(
+    @Arg('pdfTemplate') pdfTemplate: NewPDFTemplate,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplate> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(PDFTemplate).save({
+      ...pdfTemplate,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => PDFTemplate, { description: 'To modify PDFTemplate information' })
+  async updatePDFTemplate(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PDFTemplatePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplate> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(PDFTemplate)
+    const pdfTemplate = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...pdfTemplate,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [PDFTemplate], { description: "To modify multiple PDFTemplates' information" })
+  async updateMultiplePDFTemplate(
+    @Arg('patches', type => [PDFTemplatePatch]) patches: PDFTemplatePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplate[]> {
+    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 pdfTemplateRepo = tx.getRepository(PDFTemplate)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await pdfTemplateRepo.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 pdfTemplate = await pdfTemplateRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await pdfTemplateRepo.save({
+          ...pdfTemplate,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete PDFTemplate' })
+  async deletePDFTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFTemplate).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple PDFTemplates' })
+  async deletePDFTemplates(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PDFTemplate).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple PDFTemplates' })
+  async importPDFTemplates(
+    @Arg('pdfTemplates', type => [PDFTemplatePatch]) pdfTemplates: PDFTemplatePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      pdfTemplates.map(async (pdfTemplate: PDFTemplatePatch) => {
+        const createdPDFTemplate: PDFTemplate = await tx.getRepository(PDFTemplate).save({ domain, ...pdfTemplate })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/pdf-template/pdf-template-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 { PDFTemplate } from './pdf-template'
+import { PDFTemplateList } from './pdf-template-type'
+
+@Resolver(PDFTemplate)
+export class PDFTemplateQuery {
+  @Query(returns => PDFTemplate!, { nullable: true, description: 'To fetch a PDFTemplate' })
+  async PDFTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PDFTemplate> {
+    const { domain } = context.state
+
+    return await getRepository(PDFTemplate).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => PDFTemplateList, { description: 'To fetch multiple PDFTemplates' })
+  async PDFTemplates(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<PDFTemplateList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(PDFTemplate),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() pdfTemplate: PDFTemplate): Promise<Domain> {
+    return pdfTemplate.domainId && (await getRepository(Domain).findOneBy({ id: pdfTemplate.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() pdfTemplate: PDFTemplate): Promise<User> {
+    return pdfTemplate.updaterId && (await getRepository(User).findOneBy({ id: pdfTemplate.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() pdfTemplate: PDFTemplate): Promise<User> {
+    return pdfTemplate.creatorId && (await getRepository(User).findOneBy({ id: pdfTemplate.creatorId }))
+  }
+}

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

@@ -0,0 +1,87 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+
+import { PDFTemplate, PDFTemplateStatus } from './pdf-template'
+
+@InputType()
+export class NewPDFTemplate {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFTemplateStatus, { nullable: true })
+  state?: PDFTemplateStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  content_template?: string
+
+  @Field({ nullable: true })
+  header_template?: string
+
+  @Field({ nullable: true })
+  footer_template?: string
+
+  @Field({ nullable: true })
+  cover_template?: string
+
+  @Field({ nullable: true })
+  last_template?: string
+
+  @Field({ nullable: true, defaultValue: 'A4' })
+  page_size: string
+
+  @Field({ nullable: true })
+  watermark: string
+}
+
+@InputType()
+export class PDFTemplatePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => PDFTemplateStatus, { nullable: true })
+  state?: PDFTemplateStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  content_template?: string
+
+  @Field({ nullable: true })
+  header_template?: string
+
+  @Field({ nullable: true })
+  footer_template?: string
+
+  @Field({ nullable: true })
+  cover_template?: string
+
+  @Field({ nullable: true })
+  last_template?: string
+
+  @Field({ nullable: true, defaultValue: 'A4' })
+  page_size?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class PDFTemplateList {
+  @Field(type => [PDFTemplate])
+  items: PDFTemplate[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/pdf-template/pdf-template.ts

@@ -0,0 +1,108 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+export enum PDFTemplateStatus {
+  draft = 'draft',
+  released = 'released'
+}
+
+registerEnumType(PDFTemplateStatus, {
+  name: 'PDFTemplateStatus',
+  description: 'state enumeration of a PDF Template'
+})
+
+@Entity()
+@Index('ix_pdf_template_0', (pdfTemplate: PDFTemplate) => [pdfTemplate.domain, pdfTemplate.name], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for PDFTemplate' })
+export class PDFTemplate {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((pdfTemplate: PDFTemplate) => pdfTemplate.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: PDFTemplateStatus
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true })
+  content_template?: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true })
+  header_template?: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true })
+  footer_template?: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true })
+  cover_template?: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true })
+  last_template?: string
+
+  @Column({ default: 'A4' })
+  @Field({ nullable: true, defaultValue: 'A4' })
+  page_size?: string
+
+  @Column({ type: 'text', nullable: true })
+  @Field({ nullable: true })
+  watermark?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((pdfTemplate: PDFTemplate) => pdfTemplate.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((pdfTemplate: PDFTemplate) => pdfTemplate.updater)
+  updaterId?: string
+}