@things-factory/board-service 8.0.0 → 9.0.0-beta.3

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

@@ -1,58 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { Board } from './board'
-import { BoardHistory } from './board-history'
-
-@InputType()
-export class NewBoard {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  model: string
-
-  @Field({ nullable: true })
-  groupId?: string
-
-  @Field({ nullable: true })
-  thumbnail?: string
-}
-
-@InputType()
-export class BoardPatch {
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  model?: string
-
-  @Field({ nullable: true })
-  groupId?: string
-
-  @Field({ nullable: true })
-  thumbnail?: string
-}
-
-@ObjectType()
-export class BoardList {
-  @Field(type => [Board])
-  items: Board[]
-
-  @Field(type => Int)
-  total: number
-}
-
-@ObjectType()
-export class BoardHistoryList {
-  @Field(type => [BoardHistory])
-  items: BoardHistory[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/board/board.ts

@@ -1,125 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToMany,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  DeleteDateColumn,
-  UpdateDateColumn
-} from 'typeorm'
-import { Field, ID, ObjectType } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { Group } from '../group/group'
-import { PlayGroup } from '../play-group/play-group'
-import { User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index('ix_board_1', (board: Board) => [board.domain, board.name], {
-  unique: true,
-  where: '"deleted_at" IS NULL'
-})
-@Index('ix_board_3', (board: Board) => [board.domain, board.group])
-@ObjectType({ description: 'Entity for Visualization Board' })
-export class Board {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { nullable: true })
-  readonly id?: string
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain?: Domain
-
-  @RelationId((board: Board) => board.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true, default: 'draft' })
-  @Field({ nullable: true })
-  state?: 'draft' | 'released'
-
-  @Column({
-    nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-          ? 'clob'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
-  })
-  @Field({ nullable: true })
-  model?: string
-
-  @Column({
-    nullable: true,
-    type:
-      DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'longtext'
-        : DATABASE_TYPE == 'oracle'
-          ? 'clob'
-          : DATABASE_TYPE == 'mssql'
-            ? 'nvarchar'
-            : 'varchar',
-    length: DATABASE_TYPE == 'mssql' ? 'MAX' : undefined
-  })
-  @Field({ nullable: true })
-  thumbnail?: string
-
-  @ManyToOne(type => Group, group => group.boards)
-  @Field(type => Group, { nullable: true })
-  group?: Group
-
-  @RelationId((board: Board) => board.group)
-  groupId?: string
-
-  @ManyToMany(type => PlayGroup, playGroup => playGroup.boards)
-  @Field(type => [PlayGroup], { nullable: true })
-  playGroups?: PlayGroup[]
-
-  @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((board: Board) => board.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((board: Board) => board.updater)
-  updaterId?: string
-
-  @DeleteDateColumn()
-  @Field({ nullable: true })
-  deletedAt?: Date
-}

package/server/service/board/event-subscriber.ts

@@ -1,68 +0,0 @@
-import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-import { pubsub, getRepository } from '@things-factory/shell'
-
-import { Board } from './board'
-import { BoardHistory } from './board-history'
-
-@EventSubscriber()
-export class BoardSubscriber implements EntitySubscriberInterface<Board> {
-  listenTo() {
-    return Board
-  }
-
-  async beforeUpdate(event: UpdateEvent<Board>): Promise<any> {
-    var board = event.entity
-
-    if (!board.version) {
-      board.version = 0
-    }
-  }
-
-  async afterUpdate(event: UpdateEvent<Board>): Promise<any> {
-    var board = event.entity
-
-    board = await event.manager.findOne(Board, {
-      where: { domain: { id: board.domainId }, id: board.id },
-      relations: ['playGroups']
-    })
-
-    if (!board || board.state != 'released') {
-      return
-    }
-
-    board.playGroups.forEach(playGroup =>
-      pubsub.publish('play-group', {
-        playGroup
-      })
-    )
-
-    pubsub.publish('board', {
-      board
-    })
-  }
-}
-
-@EventSubscriber()
-export class BoardHistoryEntitySubscriber extends HistoryEntitySubscriber<Board, BoardHistory> {
-  public get entity() {
-    return Board
-  }
-
-  public get historyEntity() {
-    return BoardHistory
-  }
-
-  public async afterInsert(event: InsertEvent<Board>): Promise<void> {
-    if (event.entity.state == 'released') {
-      super.afterInsert(event)
-    }
-  }
-
-  public async afterUpdate(event: UpdateEvent<Board>): Promise<void> {
-    if (event.entity.state == 'released') {
-      super.afterUpdate(event)
-    }
-  }
-}

package/server/service/board/index.ts

@@ -1,10 +0,0 @@
-import { Board } from './board'
-import { BoardHistory } from './board-history'
-import { BoardQuery } from './board-query'
-import { BoardMutation } from './board-mutation'
-import { BoardSubscription } from './board-subscription'
-import { BoardSubscriber, BoardHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [Board, BoardHistory]
-export const resolvers = [BoardQuery, BoardMutation, BoardSubscription]
-export const subscribers = [BoardSubscriber, BoardHistoryEntitySubscriber]

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

@@ -1,53 +0,0 @@
-import { Args, Ctx, Query, Resolver } from 'type-graphql'
-
-import { config } from '@things-factory/env'
-import { Favorite } from '@things-factory/fav-base'
-import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
-
-import { Board } from '../board/board'
-import { BoardFavorite, BoardFavoriteList } from './board-favorite-type'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Resolver(BoardFavorite)
-export class BoardFavoriteQuery {
-  @Query(returns => BoardFavoriteList, { description: 'To fetch multiple BoardFavorites' })
-  async favoriteBoards(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<BoardFavoriteList> {
-    const { user } = context.state
-
-    const queryBuilder = getRepository(Board).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    var joinStatement = ''
-    switch (DATABASE_TYPE) {
-      case 'postgres':
-        joinStatement = 'CAST(Board.id as VARCHAR) = Favorite.routing'
-        break
-      case 'sqlite':
-      default:
-        joinStatement = 'Board.id = Favorite.routing'
-    }
-
-    var qb = queryBuilder
-      .innerJoin(Favorite, 'Favorite', joinStatement)
-      .select([
-        'Board.id as id',
-        'Board.name as name',
-        'Board.description as description',
-        'Board.thumbnail as thumbnail',
-        'Favorite.id as favoriteId'
-      ])
-      .andWhere('Favorite.user = :userId', {
-        userId: user.id
-      })
-
-    const items = await qb.getRawMany()
-    const total = await qb.getCount()
-
-    return { items, total }
-  }
-}

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

@@ -1,18 +0,0 @@
-import { ObjectType, Field, Int } from 'type-graphql'
-
-import { Board } from '../board/board'
-
-@ObjectType()
-export class BoardFavorite extends Board {
-  @Field({ nullable: true })
-  favoriteId?: string
-}
-
-@ObjectType()
-export class BoardFavoriteList {
-  @Field(type => [BoardFavorite])
-  items: BoardFavorite[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/board-favorite/index.ts

@@ -1,4 +0,0 @@
-import { BoardFavoriteQuery } from './board-favorite-query'
-
-export const entities = []
-export const resolvers = [BoardFavoriteQuery]

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

@@ -1,161 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-
-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-template", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => BoardTemplate, { description: 'To create new BoardTemplate' })
-  async createBoardTemplate(
-    @Arg('boardTemplate') boardTemplate: NewBoardTemplate,
-    @Ctx() context: ResolverContext
-  ): Promise<BoardTemplate> {
-    const { domain, user, tx } = context.state
-    const repository = tx.getRepository(BoardTemplate)
-
-    const oldBoardTemplate: BoardTemplate = await repository.findOneBy({
-      name: boardTemplate.name,
-      domain: { id: domain.id }
-    })
-
-    if (oldBoardTemplate) {
-      throw new Error(context.t('error.board-template name is already taken', { name: boardTemplate.name }))
-    }
-
-    const newBoardTemplate: Partial<BoardTemplate> = {
-      ...boardTemplate
-    }
-
-    const base64 = await thumbnail({
-      model: boardTemplate.model,
-      context
-    })
-
-    if (base64) {
-      newBoardTemplate.thumbnail = 'data:image/png;base64,' + base64.toString('base64')
-    } else {
-      newBoardTemplate.thumbnail = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
-    }
-
-    return await repository.save({
-      domain,
-      ...newBoardTemplate,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "board-template", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => BoardTemplate, { description: 'To modify BoardTemplate information' })
-  async updateBoardTemplate(
-    @Arg('id') id: string,
-    @Arg('patch') patch: BoardTemplatePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<BoardTemplate> {
-    const { domain, user, tx } = context.state
-    const repository = tx.getRepository(BoardTemplate)
-
-    const boardTemplate = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    if (patch.model) {
-      const base64 = await thumbnail({
-        model: patch.model,
-        context
-      })
-
-      if (base64) {
-        patch.thumbnail = 'data:image/png;base64,' + base64.toString('base64')
-      } else {
-        patch.thumbnail = 'data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
-      }
-    }
-
-    return await repository.save({
-      ...boardTemplate,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @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
-
-    await tx.getRepository(BoardTemplate).delete({ domain: { id: domain.id }, id })
-
-    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,121 +0,0 @@
-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'
-import { User } from '@things-factory/auth-base'
-import { BoardTemplate } from './board-template'
-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-template", privilege: "query", domainOwnerGranted: true)')
-  async boardTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<BoardTemplate> {
-    const { domain, user } = context.state
-
-    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' })
-  async boardTemplatesCreatedByMe(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<BoardTemplateList> {
-    const { user } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(BoardTemplate),
-      params,
-      alias: 'template',
-      searchables: ['name', 'description']
-    }).andWhere('template.creator = :user', { user: user.id })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => BoardTemplateList, { description: 'To fetch multiple BoardTemplates' })
-  @Directive('@privilege(category: "board-template", privilege: "query", domainOwnerGranted: true)')
-  async boardTemplates(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<BoardTemplateList> {
-    const { domain, user } = context.state
-    /* 
-      리스트에 포함되는 보드템플릿들 
-      - visibility가 public 인 경우
-      - visibility가 domain이며 컨텍스트의 도메인과 같은 경우
-      - visibility가 private 이며, creator가 나인 경우
-    */
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      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 => 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)
-  async domain(@Root() boardTemplate: BoardTemplate): Promise<Domain> {
-    return boardTemplate.domainId && (await getRepository(Domain).findOneBy({ id: boardTemplate.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() boardTemplate: BoardTemplate): Promise<User> {
-    return boardTemplate.updaterId && (await getRepository(User).findOneBy({ id: boardTemplate.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() boardTemplate: BoardTemplate): Promise<User> {
-    return boardTemplate.creatorId && (await getRepository(User).findOneBy({ id: boardTemplate.creatorId }))
-  }
-}

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

@@ -1,53 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-import { BoardTemplate } from './board-template'
-
-@InputType()
-export class NewBoardTemplate {
-  @Field()
-  name: string
-
-  @Field()
-  description: string
-
-  @Field()
-  model: string
-
-  @Field()
-  visibility: 'private' | 'public'
-
-  @Field({ nullable: true })
-  thumbnail: string
-}
-
-@InputType()
-export class BoardTemplatePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  model: string
-
-  @Field({ nullable: true })
-  visibility?: 'private' | 'public'
-
-  @Field({ nullable: true })
-  thumbnail?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class BoardTemplateList {
-  @Field(type => [BoardTemplate])
-  items: BoardTemplate[]
-
-  @Field(type => Int)
-  total: number
-}