@things-factory/board-service 6.2.15 → 6.2.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/board-service",
-  "version": "6.2.15",
+  "version": "6.2.19",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,11 +24,11 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^6.2.15",
+    "@things-factory/auth-base": "^6.2.19",
     "@things-factory/env": "^6.2.0",
-    "@things-factory/fav-base": "^6.2.15",
-    "@things-factory/font-base": "^6.2.15",
-    "@things-factory/integration-base": "^6.2.15",
+    "@things-factory/fav-base": "^6.2.19",
+    "@things-factory/font-base": "^6.2.19",
+    "@things-factory/integration-base": "^6.2.19",
     "@things-factory/operato-license-checker": "^3.1.0",
     "content-disposition": "^0.5.3",
     "generic-pool": "^3.8.2"
@@ -37,5 +37,5 @@
     "@thiagoelg/node-printer": "0.6.2",
     "puppeteer": "^20.7.3"
   },
-  "gitHead": "262fa72c069ac8745dd16acd695d0e87331fbc14"
+  "gitHead": "5b5f3c02adca0ecb6344310bfeaf27b04c5dc657"
 }

package/server/routers/standalone-board-service-router.ts

@@ -11,6 +11,7 @@ import { labelcommand } from '../controllers/label-command'
 import { pdf } from '../controllers/pdf'
 import { screenshot } from '../controllers/screenshot'
 import { Board } from '../service/board/board'
+import { BoardTemplate } from '../service/board-template/board-template'
 
 export const standaloneBoardServiceRouter = new Router()
 
@@ -216,6 +217,32 @@ standaloneBoardServiceRouter.get('/thumbnail/:id', async (context, next) => {
   }
 })
 
+// for board-template thumbnail
+standaloneBoardServiceRouter.get('/board-template-thumbnail/:id', async (context, next) => {
+  const { domain, user } = context.state
+
+  if (!(await User.hasPrivilege('query', 'board-template', domain, user))) {
+    context.status = 403
+    return
+  }
+
+  const { id } = context.params
+
+  const { name, thumbnail } = (await getRepository(BoardTemplate).findOneBy({ domain: { id: domain.id }, id })) || {}
+
+  if (thumbnail) {
+    const index = thumbnail.indexOf(';base64,')
+    const base64 = thumbnail.substring(index + 8)
+    const buffer = Buffer.from(base64, 'base64')
+
+    context.type = 'image/png'
+    context.set('Content-Disposition', contentDisposition(`thumbnail-${name}.png`))
+    context.body = buffer
+  } else {
+    context.throw(404, 'thumbnail not found')
+  }
+})
+
 // for webpage scrap
 standaloneBoardServiceRouter.get('/screenshot/:id', async (context, next) => {
   const { domain, user } = context.state

package/server/service/board/board-mutation.ts

@@ -55,10 +55,12 @@ export class BoardMutation {
     }
 
     const newBoard: Board = {
-      ...board,
-      thumbnail: 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==' /* empty thumbnail */
+      ...board
     }
 
+    newBoard.thumbnail ||=
+      'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==' /* empty thumbnail */
+
     if (board.groupId) {
       newBoard.group = await groupRepository.findOneBy({
         id: board.groupId
@@ -239,7 +241,7 @@ export class BoardMutation {
 
   @Directive('@transaction')
   @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Board, { description: 'To release Board information' })
+  @Mutation(returns => Board, { description: 'To release a Board' })
   async releaseBoard(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Board> {
     const { domain, user, notify, tx } = context.state
     const repository = tx.getRepository(Board)

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

@@ -1,13 +1,15 @@
 import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
 
-import { thumbnail } from '../../controllers/thumbnail'
+import { getRedirectSubdomainPath } from '@things-factory/shell'
 import { BoardTemplate } from './board-template'
+import { Board } from '../board/board'
 import { NewBoardTemplate, BoardTemplatePatch } from './board-template-type'
+import { thumbnail } from '../../controllers/thumbnail'
 
 @Resolver(BoardTemplate)
 export class BoardTemplateMutation {
   @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@privilege(category: "board-template", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => BoardTemplate, { description: 'To create new BoardTemplate' })
   async createBoardTemplate(
     @Arg('boardTemplate') boardTemplate: NewBoardTemplate,
@@ -49,7 +51,7 @@ export class BoardTemplateMutation {
   }
 
   @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@privilege(category: "board-template", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => BoardTemplate, { description: 'To modify BoardTemplate information' })
   async updateBoardTemplate(
     @Arg('id') id: string,
@@ -84,7 +86,7 @@ export class BoardTemplateMutation {
   }
 
   @Directive('@transaction')
-  @Directive('@privilege(category: "board", privilege: "mutation", domainOwnerGranted: true)')
+  @Directive('@privilege(category: "board-template", privilege: "mutation", domainOwnerGranted: true)')
   @Mutation(returns => Boolean, { description: 'To delete BoardTemplate' })
   async deleteBoardTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
@@ -93,4 +95,67 @@ export class BoardTemplateMutation {
 
     return true
   }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "board-template", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => BoardTemplate, { description: 'To register a board as a board template with the given ID' })
+  async registerBoardAsTemplate(
+    @Arg('id', { description: 'board Id to be regiestered' }) id: string,
+    @Arg('name', { description: 'name of board template to be regiestered' }) name: string,
+    @Arg('description', { description: 'description of board template to be regiestered' }) description: string,
+    @Arg('visibility', { description: 'visibility of board template to be regiestered' }) visibility: string,
+    @Ctx() context: ResolverContext
+  ): Promise<BoardTemplate> {
+    const { domain, user, notify, tx } = context.state
+
+    const boardTemplateRepository = tx.getRepository(BoardTemplate)
+
+    const board = await tx.getRepository(Board).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    if (!board) {
+      throw `Board given id(${id}) is not found`
+    }
+
+    name ||= board.name
+
+    const { model, thumbnail } = board
+
+    const boardTemplate = await boardTemplateRepository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    const registered = boardTemplate
+      ? await boardTemplateRepository.save({
+          ...boardTemplate,
+          name,
+          description: description || boardTemplate.description,
+          visibility: visibility || boardTemplate.visibility,
+          model,
+          thumbnail,
+          updater: user
+        })
+      : await boardTemplateRepository.save({
+          domain: { id: domain.id },
+          name,
+          description: description || board.description,
+          model,
+          thumbnail,
+          visibility: visibility || 'private',
+          updater: user,
+          creator: user
+        })
+
+    notify &&
+      notify({
+        mode: 'in-app',
+        title: `BoardTemplate '${registered.name}' registered`,
+        body: `BoardTemplate '${registered.name}' registered by ${user.name}\n${registered.description}`,
+        image: getRedirectSubdomainPath(context, domain.subdomain, `/board-template-thumbnail/${registered.id}`),
+        url: getRedirectSubdomainPath(context, domain.subdomain, `/board-template-viewer/${registered.id}`)
+      })
+
+    return registered
+  }
 }

package/server/service/board-template/board-template-query.ts

@@ -1,4 +1,4 @@
-import { In } from 'typeorm'
+import { Brackets, In } from 'typeorm'
 import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
 import { Attachment } from '@things-factory/attachment-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
@@ -9,23 +9,35 @@ import { BoardTemplateList } from './board-template-type'
 @Resolver(BoardTemplate)
 export class BoardTemplateQuery {
   @Query(returns => BoardTemplate!, { nullable: true, description: 'To fetch a BoardTemplate' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
+  @Directive('@privilege(category: "board-template", privilege: "query", domainOwnerGranted: true)')
   async boardTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<BoardTemplate> {
-    const { domain } = context.state
-
-    return await getRepository(BoardTemplate).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-  }
-
-  @Query(returns => BoardTemplate, { nullable: true, description: 'To fetch a BoardTemplate by name' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
-  async boardTemplateByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<BoardTemplate> {
-    const { domain } = context.state
+    const { domain, user } = context.state
 
-    return await getRepository(BoardTemplate).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, name }
-    })
+    const qb = await getRepository(BoardTemplate)
+      .createQueryBuilder('BoardTemplate')
+      .where('id=:id', { id })
+      .andWhere(
+        new Brackets(qb => {
+          qb.where({ visibility: 'public' })
+            .orWhere({
+              visibility: 'domain',
+              domain: { id: In([domain.id, domain.parentId]) }
+            })
+            .orWhere({
+              visibility: 'private',
+              creator: { id: user.id }
+            })
+        })
+      )
+
+    return qb.getOne()
+
+    // return await getRepository(BoardTemplate).findOne({
+    //   where: {
+    //     domain: { id: In([domain.id, domain.parentId].filter(Boolean)) },
+    //     id
+    //   }
+    // })
   }
 
   @Query(returns => BoardTemplateList, { description: 'To fetch BoardTemplates created by me' })
@@ -33,12 +45,11 @@ export class BoardTemplateQuery {
     @Args() params: ListParam,
     @Ctx() context: ResolverContext
   ): Promise<BoardTemplateList> {
-    const { domain, user } = context.state
+    const { user } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
       repository: getRepository(BoardTemplate),
       params,
-      domain,
       alias: 'template',
       searchables: ['name', 'description']
     }).andWhere('template.creator = :user', { user: user.id })
@@ -49,33 +60,45 @@ export class BoardTemplateQuery {
   }
 
   @Query(returns => BoardTemplateList, { description: 'To fetch multiple BoardTemplates' })
-  @Directive('@privilege(category: "board", privilege: "query", domainOwnerGranted: true)')
+  @Directive('@privilege(category: "board-template", privilege: "query", domainOwnerGranted: true)')
   async boardTemplates(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<BoardTemplateList> {
-    const { domain } = context.state
+    const { domain, user } = context.state
+    /* 
+      리스트에 포함되는 보드템플릿들 
+      - visibility가 public 인 경우
+      - visibility가 domain이며 컨텍스트의 도메인과 같은 경우
+      - visibility가 private 이며, creator가 나인 경우
+    */
 
     const queryBuilder = getQueryBuilderFromListParams({
-      domain,
       params,
       repository: await getRepository(BoardTemplate),
       searchables: ['name', 'description']
-    })
+    }).andWhere(
+      new Brackets(qb => {
+        qb.where({ visibility: 'public' })
+          .orWhere({
+            visibility: 'domain',
+            domain: { id: In([domain.id, domain.parentId]) }
+          })
+          .orWhere({
+            visibility: 'private',
+            creator: { id: user.id }
+          })
+      })
+    )
 
     const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }
   }
 
-  @FieldResolver(type => String)
-  async thumbnail(@Root() boardTemplate: BoardTemplate): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: boardTemplate.domainId },
-        refType: BoardTemplate.name,
-        refBy: boardTemplate.id
-      }
-    })
-
-    return attachment?.fullpath
+  @FieldResolver(type => Boolean)
+  async mine(@Root() boardTemplate: BoardTemplate, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { creatorId } = boardTemplate
+    const { user } = context.state
+
+    return creatorId == user.id
   }
 
   @FieldResolver(type => Domain)

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

@@ -1,27 +1,22 @@
-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 { BoardTemplate, BoardTemplateStatus } from './board-template'
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+import { BoardTemplate } from './board-template'
 
 @InputType()
 export class NewBoardTemplate {
   @Field()
   name: string
 
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => BoardTemplateStatus, { nullable: true })
-  state?: BoardTemplateStatus
+  @Field()
+  description: string
 
   @Field()
   model: string
 
+  @Field()
+  visibility: 'private' | 'public'
+
   @Field({ nullable: true })
-  thumbnail?: string
+  thumbnail: string
 }
 
 @InputType()
@@ -35,12 +30,12 @@ export class BoardTemplatePatch {
   @Field({ nullable: true })
   description?: string
 
-  @Field(type => BoardTemplateStatus, { nullable: true })
-  state?: BoardTemplateStatus
-
-  @Field()
+  @Field({ nullable: true })
   model: string
 
+  @Field({ nullable: true })
+  visibility?: 'private' | 'public'
+
   @Field({ nullable: true })
   thumbnail?: string
 

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

@@ -6,12 +6,11 @@ import {
   Column,
   RelationId,
   ManyToOne,
-  PrimaryGeneratedColumn,
-  VersionColumn
+  PrimaryGeneratedColumn
 } from 'typeorm'
 import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
 
-import { Domain } from '@things-factory/shell'
+import { Domain, ScalarObject } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
 
@@ -38,10 +37,6 @@ export class BoardTemplate {
   @Field(type => ID)
   readonly id: string
 
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
-
   @ManyToOne(type => Domain)
   @Field({ nullable: true })
   domain?: Domain
@@ -57,9 +52,13 @@ export class BoardTemplate {
   @Field({ nullable: true })
   description?: string
 
-  @Column({ nullable: true })
+  @Column('simple-json', { nullable: true, default: null })
+  @Field(type => ScalarObject, { nullable: true })
+  tags?: string[]
+
+  @Column({ nullable: true, default: 'private' })
   @Field({ nullable: true })
-  state?: BoardTemplateStatus
+  visibility?: string // 'private' | 'public' | 'domain'
 
   @Column({
     nullable: true,