@things-factory/board-service 8.0.0-beta.8 → 8.0.0

package/server/service/play-group/play-group-query.ts

@@ -0,0 +1,92 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Board } from '../board/board'
+import { PlayGroup } from './play-group'
+import { PlayGroupList } from './play-group-type'
+
+@Resolver(PlayGroup)
+export class PlayGroupQuery {
+  @Query(returns => PlayGroup, { nullable: true, description: 'To fetch a PlayGroup' })
+  async playGroup(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<PlayGroup> {
+    const { domain } = context.state
+
+    return await getRepository(PlayGroup).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => PlayGroup, { nullable: true, description: 'To fetch a PlayGroup by name' })
+  async playGroupByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<PlayGroup> {
+    const { domain } = context.state
+
+    return await getRepository(PlayGroup).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  }
+
+  @Query(returns => PlayGroupList, { description: 'To fetch multiple PlayGroups' })
+  async playGroups(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<PlayGroupList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(PlayGroup),
+      params,
+      domain,
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => [Board])
+  async boards(@Root() playGroup) {
+    const { order = [], boards = [] } = await getRepository(PlayGroup).findOne({
+      where: { id: playGroup.id },
+      relations: ['boards']
+    })
+
+    return boards.sort((a, b) => {
+      // 배열 A에 포함된 아이디의 순서를 가져옵니다.
+      const indexOfOrder = (order || []).indexOf(a.id)
+      const indexOfBoards = (order || []).indexOf(b.id)
+
+      // 두 아이디의 순서를 비교하여 정렬합니다.
+      if (indexOfOrder === -1 && indexOfBoards === -1) {
+        // 두 아이디 모두 배열 A에 없는 경우, 그대로 유지합니다.
+        return 0
+      } else if (indexOfOrder === -1) {
+        // 아이디 A만 배열 A에 없는 경우, 아이디 B를 먼저 정렬합니다.
+        return 1
+      } else if (indexOfBoards === -1) {
+        // 아이디 B만 배열 A에 없는 경우, 아이디 A를 먼저 정렬합니다.
+        return -1
+      } else {
+        // 두 아이디 모두 배열 A에 있는 경우, 배열 A의 아이디 순서대로 정렬합니다.
+        return indexOfOrder - indexOfBoards
+      }
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() playGroup: PlayGroup) {
+    return await getRepository(Domain).findOneBy({ id: playGroup.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() playGroup: PlayGroup): Promise<User> {
+    return await getRepository(User).findOneBy({ id: playGroup.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() playGroup: PlayGroup): Promise<User> {
+    return await getRepository(User).findOneBy({ id: playGroup.creatorId })
+  }
+}

package/server/service/play-group/play-group-subscription.ts

@@ -0,0 +1,43 @@
+import { Resolver, Subscription, Root, Arg } from 'type-graphql'
+import { filter, pipe } from 'graphql-yoga'
+import { pubsub } from '@things-factory/shell'
+import { PlayGroup } from './play-group'
+
+@Resolver(PlayGroup)
+export class PlayGroupSubscription {
+  @Subscription({
+    subscribe: ({ args, context, info }) => {
+      const { domain, user } = context.state
+      const { id } = args
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      return pipe(
+        pubsub.subscribe('play-group'),
+        filter((payload: { playGroup: PlayGroup }) => {
+          const { id: playGroupId, domainId } = payload.playGroup
+
+          if (domainId !== domain.id) {
+            return false
+          }
+
+          if (id !== playGroupId) {
+            return false
+          }
+
+          return true
+        })
+      )
+    }
+  })
+  playGroup(@Root() payload: { playGroup: PlayGroup }, @Arg('id') id: string): PlayGroup {
+    return payload.playGroup
+  }
+}

package/server/service/play-group/play-group-type.ts

@@ -0,0 +1,30 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { PlayGroup } from './play-group'
+
+@InputType()
+export class NewPlayGroup {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@InputType()
+export class PlayGroupPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@ObjectType()
+export class PlayGroupList {
+  @Field(type => [PlayGroup])
+  items: PlayGroup[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/play-group/play-group.ts

@@ -0,0 +1,74 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinTable,
+  ManyToMany,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Board } from '../board/board'
+
+@Entity()
+@Index('ix_play_group_0', (playGroup: PlayGroup) => [playGroup.domain, playGroup.name], { unique: true })
+@ObjectType({ description: 'Entity for Board PlayGroup' })
+export class PlayGroup {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain?: Domain
+
+  @RelationId((playGroup: PlayGroup) => playGroup.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @ManyToMany(type => Board, board => board.playGroups)
+  @JoinTable({ name: 'play_groups_boards' })
+  @Field(type => [Board], { nullable: true })
+  boards: Board[]
+
+  @Column('simple-json', { nullable: true })
+  order: any
+
+  @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((playGroup: PlayGroup) => playGroup.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((playGroup: PlayGroup) => playGroup.updater)
+  updaterId?: string
+}

package/server/service/theme/index.ts

@@ -0,0 +1,7 @@
+import { Theme } from './theme'
+import { ThemeQuery } from './theme-query'
+import { ThemeMutation } from './theme-mutation'
+
+export const entities = [Theme]
+export const resolvers = [ThemeQuery, ThemeMutation]
+export const subscribers = []

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

@@ -0,0 +1,128 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Theme } from './theme'
+import { NewTheme, ThemePatch } from './theme-type'
+
+@Resolver(Theme)
+export class ThemeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Theme, { description: 'To create new Theme' })
+  async createTheme(@Arg('theme') theme: NewTheme, @Ctx() context: ResolverContext): Promise<Theme> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Theme).save({
+      ...theme,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Theme, { description: 'To modify Theme information' })
+  async updateTheme(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ThemePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Theme> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Theme)
+    const theme = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...theme,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Theme], { description: "To modify multiple Themes' information" })
+  async updateMultipleTheme(
+    @Arg('patches', type => [ThemePatch]) patches: ThemePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Theme[]> {
+    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 themeRepo = tx.getRepository(Theme)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await themeRepo.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 theme = await themeRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await themeRepo.save({
+          ...theme,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Theme' })
+  async deleteTheme(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Theme).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Themes' })
+  async deleteThemes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Theme).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple Themes' })
+  async importThemes(
+    @Arg('themes', type => [ThemePatch]) themes: ThemePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      themes.map(async (theme: ThemePatch) => {
+        const createdTheme: Theme = await tx.getRepository(Theme).save({ domain, ...theme })
+      })
+    )
+
+    return true
+  }
+}

package/server/service/theme/theme-query.ts

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

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

@@ -0,0 +1,55 @@
+import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
+
+import { ScalarObject } from '@things-factory/shell'
+import { Theme } from './theme'
+
+@InputType()
+export class NewTheme {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  value?: any
+}
+
+@InputType()
+export class ThemePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  value?: any
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ThemeList {
+  @Field(type => [Theme])
+  items: Theme[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/theme/theme.ts

@@ -0,0 +1,97 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+export interface ThemeType {
+  name: string
+  propType: string
+}
+
+var ThemeTypes: { [name: string]: ThemeType } = {
+  Legend: {
+    name: 'Legend',
+    propType: 'legend'
+  }
+}
+
+@Entity()
+@Index('ix_theme_0', (theme: Theme) => [theme.domain, theme.name, theme.deletedAt], { unique: true })
+@ObjectType({ description: 'Entity for Theme' })
+export class Theme {
+  static registerThemeType(themeType: ThemeType) {
+    ThemeTypes[themeType.name] = themeType
+  }
+
+  static getThemeType(name: string) {
+    return ThemeTypes[name]
+  }
+
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((theme: Theme) => theme.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 })
+  type?: string
+
+  @Column('simple-json', { nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  value?: any
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @DeleteDateColumn()
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((theme: Theme) => theme.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((theme: Theme) => theme.updater)
+  updaterId?: string
+}

package/views/internal-board-full-feature-view.html

@@ -69,7 +69,7 @@
       const startSubscribingForAutoRefresh = window.startSubscribingForAutoRefresh
 
       const board = {
-        id: (new URL(window.location.href)).pathname.split('/').at(-1),
+        id: '---',
         model
       }