@things-factory/meta-ui 8.0.0-beta.9 → 8.0.2

package/server/service/menu-button-auth/menu-button-auth-query.ts

@@ -0,0 +1,138 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { IsNull, Not } from 'typeorm'
+import {
+  Domain,
+  ListParam,
+  convertListParams,
+  getRepository,
+  getQueryBuilderFromListParams
+} from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { MenuButtonAuth } from './menu-button-auth'
+import { MenuButtonAuthList } from './menu-button-auth-type'
+import { Menu } from '@things-factory/menu-base'
+import { ButtonRole } from './../button-role/button-role'
+
+@Resolver(MenuButtonAuth)
+export class MenuButtonAuthQuery {
+  @Query(returns => MenuButtonAuth, { description: 'To fetch a MenuButtonAuth' })
+  async menuButtonAuth(@Arg('id') id: string, @Ctx() context: any): Promise<MenuButtonAuth> {
+    const { domain } = context.state
+    return await getRepository(MenuButtonAuth).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => MenuButtonAuthList, { description: 'To fetch a multiple MenuButtonAuth' })
+  async menuButtonAuths(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<MenuButtonAuthList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(MenuButtonAuth)
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => MenuButtonAuthList, { description: 'To fetch a multiple RoleMenuButtonAuth' })
+  async roleMenuButtonAuths(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: any
+  ): Promise<MenuButtonAuthList> {
+    const { domain } = context.state
+    const roleId = params.filters.find(x => x.name == 'roleId').value
+    const parentMenuId = params.filters.some(x => x.name == 'menuId')
+      ? params.filters.find(x => x.name == 'menuId').value
+      : undefined
+
+    // 기존 role 권한 조회
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(MenuButtonAuth)
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    // 메뉴 리스트 조회
+    let menuParams = {
+      where: {
+        domain: {
+          id: domain.id
+        }
+      },
+      order: { rank: 'ASC' }
+    }
+
+    if (parentMenuId) {
+      menuParams.where['parent'] = {
+        id: parentMenuId
+      }
+    } else {
+      menuParams.where['parent'] = Not(IsNull())
+    }
+
+    const menus: Menu[] = await getRepository(Menu).find(menuParams as any)
+
+    let results: MenuButtonAuth[] = []
+
+    menus.forEach(menu => {
+      let menuRole = {
+        id: menu.id,
+        menu: menu,
+        menuId: menu.id,
+        roleId: roleId,
+        role: { id: roleId, name: '', description: '', domain: domain, domainId: domain.id },
+        domain: domain,
+        domainId: domain.id,
+        selectAuth: false,
+        createAuth: false,
+        updateAuth: false,
+        deleteAuth: false
+      }
+
+      if (items.some(x => x.menuId == menu.id)) {
+        let menuAuth = items.find(x => x.menuId == menu.id)
+
+        menuRole.id = menuAuth.id
+        menuRole.selectAuth = menuAuth.selectAuth
+        menuRole.updateAuth = menuAuth.updateAuth
+        menuRole.createAuth = menuAuth.createAuth
+        menuRole.deleteAuth = menuAuth.deleteAuth
+      }
+
+      results.push(menuRole)
+    })
+
+    return { items: results, total: 0 }
+  }
+
+  @FieldResolver(type => ButtonRole)
+  async role(@Root() menuButtonAuth: MenuButtonAuth): Promise<ButtonRole> {
+    return await getRepository(ButtonRole).findOneBy({ id: menuButtonAuth.roleId })
+  }
+
+  @FieldResolver(type => Menu)
+  async menu(@Root() menuButtonAuth: MenuButtonAuth): Promise<Menu> {
+    return await getRepository(Menu).findOneBy({ id: menuButtonAuth.menuId })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() menuButtonAuth: MenuButtonAuth): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: menuButtonAuth.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() menuButtonAuth: MenuButtonAuth): Promise<User> {
+    return await getRepository(User).findOneBy({ id: menuButtonAuth.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() menuButtonAuth: MenuButtonAuth): Promise<User> {
+    return await getRepository(User).findOneBy({ id: menuButtonAuth.creatorId })
+  }
+}

package/server/service/menu-button-auth/menu-button-auth-type.ts

@@ -0,0 +1,63 @@
+
+import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+
+import { MenuButtonAuth } from './menu-button-auth'
+
+@InputType()
+export class NewMenuButtonAuth {
+
+  @Field(type => ObjectRef)
+  role: ObjectRef
+
+  @Field(type => ObjectRef)
+  menu: ObjectRef
+
+  @Field({ nullable: false })
+  selectAuth?: boolean
+
+  @Field({ nullable: true })
+  createAuth?: boolean
+
+  @Field({ nullable: true })
+  updateAuth?: boolean
+
+  @Field({ nullable: true })
+  deleteAuth?: boolean
+}
+
+@InputType()
+export class MenuButtonAuthPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef)
+  role: ObjectRef
+
+  @Field(type => ObjectRef)
+  menu: ObjectRef
+
+  @Field({ nullable: false })
+  selectAuth?: boolean
+
+  @Field({ nullable: true })
+  createAuth?: boolean
+
+  @Field({ nullable: true })
+  updateAuth?: boolean
+
+  @Field({ nullable: true })
+  deleteAuth?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class MenuButtonAuthList {
+  @Field(type => [MenuButtonAuth])
+  items: MenuButtonAuth[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/menu-button-auth/menu-button-auth.ts

@@ -0,0 +1,92 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, Float, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Menu } from '@things-factory/menu-base'
+import { ButtonRole } from './../button-role/button-role'
+
+@Entity('menu_button_auth')
+@Index(
+  'ix_menu_button_auth_0',
+  (menuButtonAuth: MenuButtonAuth) => [menuButtonAuth.domain, menuButtonAuth.role, menuButtonAuth.menu],
+  { unique: true }
+)
+@Index('ix_menu_button_auth_1', (menuButtonAuth: MenuButtonAuth) => [menuButtonAuth.domain, menuButtonAuth.role], {
+  unique: false
+})
+@ObjectType({ description: 'Entity for MenuButtonAuth' })
+export class MenuButtonAuth {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => ButtonRole, { createForeignKeyConstraints: false, nullable: false })
+  @Field({ nullable: false })
+  role: ButtonRole
+
+  @RelationId((menuButtonAuth: MenuButtonAuth) => menuButtonAuth.role)
+  roleId: string
+
+  @ManyToOne(type => Menu, { createForeignKeyConstraints: false, nullable: false })
+  @Field({ nullable: false })
+  menu: Menu
+
+  @RelationId((menuButtonAuth: MenuButtonAuth) => menuButtonAuth.menu)
+  menuId: string
+
+  @Column({ name: 'select_auth', type: 'boolean', nullable: true, default: false })
+  @Field({ nullable: true })
+  selectAuth?: boolean
+
+  @Column({ name: 'create_auth', type: 'boolean', nullable: true, default: false })
+  @Field({ nullable: true })
+  createAuth?: boolean
+
+  @Column({ name: 'update_auth', type: 'boolean', nullable: true, default: false })
+  @Field({ nullable: true })
+  updateAuth?: boolean
+
+  @Column({ name: 'delete_auth', type: 'boolean', nullable: true, default: false })
+  @Field({ nullable: true })
+  deleteAuth?: boolean
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: false })
+  domain: Domain
+
+  @RelationId((menuButtonAuth: MenuButtonAuth) => menuButtonAuth.domain)
+  domainId: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { createForeignKeyConstraints: false, nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((menuButtonAuth: MenuButtonAuth) => menuButtonAuth.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { createForeignKeyConstraints: false, nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((menuButtonAuth: MenuButtonAuth) => menuButtonAuth.updater)
+  updaterId?: string
+}

package/server/service/meta-activity/index.ts

@@ -0,0 +1,5 @@
+
+import { MetaActivityMutation } from './meta-activity-mutation'
+import { MetaActivityQuery } from './meta-activity-query'
+
+export const resolvers = [ MetaActivityQuery, MetaActivityMutation ]

package/server/service/meta-activity/meta-activity-mutation.ts

@@ -0,0 +1,191 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { ActivityInstallations, Activity, ActivityStatus, ActivityTemplate } from '@things-factory/worklist'
+import { MetaActivityPatch } from './meta-activity-type'
+import { Menu } from '@things-factory/menu-base'
+import { callback } from './../../activity/CommonActivity'
+const path = require('path')
+const { appRootPath } = require('@things-factory/env')
+const AppPackage = require(path.resolve(appRootPath, 'package.json'))
+
+@Resolver(Activity)
+export class MetaActivityMutation {
+  async findMenuModel(tx: any, menuObj: any) {
+    if (!menuObj) return []
+
+    let menu = await tx.getRepository(Menu).findOne({ where: { id: menuObj.id } })
+    if (!menu) return []
+
+    return [
+      {
+        name: 'relation-menu',
+        description: JSON.stringify({
+          id: menu.id,
+          name: menu.name,
+          routing: menu.routing
+        })
+      },
+      {
+        name: 'customData',
+        inout: 'inout'
+      }
+    ]
+  }
+
+  async removeActivityTemplate(activity: Activity) {
+    if (activity) {
+      if (ActivityInstallations.get(activity.name)) {
+        delete ActivityInstallations.templates[activity.name]
+      }
+    }
+  }
+
+  async addActivityTemplate(activity: Activity) {
+    if (activity.state == ActivityStatus.Released) {
+      ActivityInstallations.installActivityTemplate({
+        name: `${activity.name}`,
+        release: AppPackage.version,
+        description: activity.description,
+        provider: AppPackage.provider,
+        // category: activity.category,
+        activityType: activity.activityType,
+        priority: activity.priority,
+        // searchKeys: [],
+        // startable: true,
+        startingType: activity.startingType,
+        model: activity.model,
+        uiType: activity.uiType,
+        uiSource: activity.uiSource,
+        viewType: activity.viewType,
+        viewSource: activity.viewSource,
+        activity: activity,
+        callback
+      })
+    }
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => [Activity], { description: "To modify multiple MetaActivities' information" })
+  async updateMultipleMetaActivity(
+    @Arg('patches', type => [MetaActivityPatch]) patches: MetaActivityPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Activity[]> {
+    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 activityRepo = tx.getRepository(Activity)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+        let model = await this.findMenuModel(tx, newRecord.menu)
+        const trxRecord = {
+          ...newRecord,
+          model,
+          domain,
+          creator: user,
+          updater: user
+        }
+        const result = await activityRepo.save(trxRecord as any)
+        results.push({ ...result, cuFlag: '+' })
+        this.addActivityTemplate(trxRecord as any)
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        let model = await this.findMenuModel(tx, updateRecord.menu)
+        const activity = await activityRepo.findOne({
+          where: { id: updateRecord.id },
+          /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
+          relations: ['domain', 'creator', 'updater']
+        })
+
+        const trxRecord = {
+          ...activity,
+          ...updateRecord,
+          model,
+          updater: user
+        }
+
+        const result = await activityRepo.save(trxRecord as any)
+        results.push({ ...result, cuFlag: 'M' })
+        this.addActivityTemplate(trxRecord as any)
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple MetaActivities' })
+  async deleteMetaActivities(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    let activityRepo = tx.getRepository(Activity)
+    let deleteActivities: Activity[] = []
+    for (let i = 0; i < ids.length; i++) {
+      deleteActivities.push(
+        await activityRepo.findOne({
+          where: { id: ids[i] }
+        })
+      )
+    }
+
+    await tx.getRepository(Activity).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    for (let i = 0; i < deleteActivities.length; i++) {
+      await this.removeActivityTemplate(deleteActivities[i])
+    }
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To install Activity Templates' })
+  async installActivityTemplate(@Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
+    const releaseActivityTemplates: Activity[] = await tx.getRepository(Activity).find({
+      where: {
+        domain: { id: domain.id },
+        state: ActivityStatus.Released
+      }
+    })
+
+    ;(releaseActivityTemplates || []).forEach(activity => {
+      if (activity.model && activity.model.some(x => x.name == 'relation-menu')) {
+        ActivityInstallations.installActivityTemplate({
+          name: `${activity.name}`,
+          release: AppPackage.version,
+          description: activity.description,
+          provider: AppPackage.provider,
+          // category: activity.category,
+          activityType: activity.activityType,
+          priority: activity.priority,
+          // searchKeys: [],
+          // startable: true,
+          startingType: activity.startingType,
+          model: activity.model,
+          uiType: activity.uiType,
+          uiSource: activity.uiSource,
+          viewType: activity.viewType,
+          viewSource: activity.viewSource,
+          activity: activity,
+          callback
+        })
+      }
+    })
+
+    return true
+  }
+}

package/server/service/meta-activity/meta-activity-query.ts

@@ -0,0 +1,43 @@
+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 { Activity } from '@things-factory/worklist'
+import { MetaActivityList } from './meta-activity-type'
+
+@Resolver(Activity)
+export class MetaActivityQuery {
+  @Query(returns => MetaActivityList, { description: 'To fetch multiple Activities' })
+  async metaActivities(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<MetaActivityList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: getRepository(Activity),
+      alias: 'activity',
+      searchables: ['name', 'description', 'model']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() activity: Activity): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: activity.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() activity: Activity): Promise<User> {
+    return await getRepository(User).findOneBy({ id: activity.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() activity: Activity): Promise<User> {
+    return await getRepository(User).findOneBy({ id: activity.creatorId })
+  }
+}

package/server/service/meta-activity/meta-activity-type.ts

@@ -0,0 +1,56 @@
+
+import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+import { Activity } from '@things-factory/worklist'
+
+
+@InputType()
+export class MetaActivityPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  state?: string
+
+  @Field(type => ObjectRef, { nullable: true }) 
+  menu?: ObjectRef
+
+  @Field({ nullable: true })
+  activityType?: string
+
+  @Field({ nullable: true })
+  startingType?: string
+
+  @Field({ nullable: true })
+  multiple?: string
+
+  @Field({ nullable: true })
+  uiType?: string
+
+  @Field({ nullable: true })
+  uiSource?: string
+
+  @Field({ nullable: true })
+  viewType?: string
+
+  @Field({ nullable: true })
+  viewSource?: string
+  
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class MetaActivityList {
+  @Field(type => [Activity])
+  items: Activity[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/set-translations/index.ts

@@ -0,0 +1,3 @@
+import { SetTranslationResolver } from './set-translation-resolver'
+
+export const resolvers = [SetTranslationResolver]

package/server/service/set-translations/set-translation-resolver.ts

@@ -0,0 +1,63 @@
+import fs from 'fs'
+import { resolve, join } from 'path'
+
+import { Arg, Query, Resolver } from 'type-graphql'
+
+@Resolver()
+export class SetTranslationResolver {
+  @Query(returns => Boolean, { description: 'To save terms for entity columns in JSON files' })
+  async setTranslations(
+    @Arg('bundle') bundle: string,
+    @Arg('terms', type => [String]) terms: string[]
+  ): Promise<Boolean> {
+    return await syncTranslationFiles(bundle, terms)
+  }
+}
+
+export async function syncTranslationFiles(bundle, terms) {
+  const PACKAGES_PATH = getPackageRootPath();
+  const TRANSLATIONS_DIR_NAME = 'translations'
+  const JSON_EXT = 'json'
+
+  const TRANSLATIONS_PATH = join(PACKAGES_PATH, bundle, TRANSLATIONS_DIR_NAME)
+
+  const fileList = fs.readdirSync(TRANSLATIONS_PATH)
+  fileList.forEach(file => {
+    const ext = file.split('.').pop().toLowerCase()
+    if (ext === JSON_EXT) {
+      const translationFile = fs.readFileSync(join(TRANSLATIONS_PATH, file))
+      const translations = JSON.parse(translationFile.toString())
+
+      terms.forEach(term => {
+        if (!(term in translations)) {
+          const text = term.split('.').pop()
+          translations[term] = text.replaceAll('_', ' ')
+        }
+      })
+
+      const updatedTranslations = JSON.stringify(translations, null, '\t')
+      fs.writeFileSync(join(TRANSLATIONS_PATH, file), updatedTranslations)
+    } else return
+  })
+
+  return true
+}
+
+  /**
+   * 프로젝트 Package Path 구하기 
+   * @returns String
+   */
+  function getPackageRootPath() {
+    let appPath: string = process.env.PWD;
+    let splitPath: string[] = appPath.split('/');
+    let pathArr: string[] = [];
+    for (let i = 0; i < splitPath.length; i++) {
+      pathArr.push(splitPath[i]);
+
+      if (splitPath[i] == 'packages') {
+        break;
+      }
+    }
+
+    return pathArr.join('/');
+  }

package/server/service/work-code/index.ts

@@ -0,0 +1,6 @@
+import { WorkCode } from './work-code'
+import { WorkCodeQuery } from './work-code-query'
+import { WorkCodeMutation } from './work-code-mutation'
+
+export const entities = [WorkCode]
+export const resolvers = [WorkCodeQuery, WorkCodeMutation]