@things-factory/meta-ui 8.0.39 → 9.0.0-9.0.0-beta.59.0

package/server/service/dynamic-menu/dynamic-menu-type.ts

@@ -1,74 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
-
-import { Menu } from '@things-factory/menu-base'
-import { Entity, EntityColumn } from '@things-factory/resource-base'
-import { Terminology } from '@things-factory/i18n-base'
-
-@ObjectType()
-export class DynamicMenuList {
-  @Field(type => [Menu])
-  items: Menu[]
-
-  @Field(type => Int)
-  total: number
-}
-
-@ObjectType()
-export class DBIndex {
-  @Field(type => String)
-  name: string
-
-  @Field(type => Boolean)
-  isUnique: boolean
-
-  @Field(type => [String], { nullable: true })
-  columns?: string[]
-}
-
-@ObjectType()
-export class DBColumn {
-  @Field(type => String)
-  name: string
-
-  @Field(type => Boolean)
-  isNullable: boolean
-
-  @Field(type => String)
-  length: string
-
-  @Field(type => String)
-  type: string
-
-  @Field(type => String || Number || Boolean, { nullable: true })
-  default?: any
-}
-
-@ObjectType()
-export class ExportMenuInfo {
-  @Field(type => String)
-  id: string
-
-  @Field(type => Menu, { nullable: true })
-  menu?: Menu
-
-  @Field(type => Menu, { nullable: true })
-  parentMenu?: Menu
-
-  @Field(type => Entity, { nullable: true })
-  entity?: Entity
-
-  @Field(type => [EntityColumn], { nullable: true })
-  entityColumns?: EntityColumn[]
-
-  @Field(type => [Terminology], { nullable: true })
-  termsLabel?: Terminology[]
-
-  @Field(type => [Terminology], { nullable: true })
-  termsTitle?: Terminology[]
-
-  @Field(type => [DBIndex], { nullable: true })
-  indices?: DBIndex[]
-
-  @Field(type => [DBColumn], { nullable: true })
-  columns?: DBColumn[]
-}

package/server/service/dynamic-menu/index.ts

@@ -1,3 +0,0 @@
-import { DynamicMenuQuery } from './dynamic-menu-query'
-
-export const resolvers = [DynamicMenuQuery]

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

@@ -1,80 +0,0 @@
-import { EventSubscriber, InsertEvent, UpdateEvent, EntitySubscriberInterface } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-import { Entity, EntityColumn } from '@things-factory/resource-base'
-import { generateId } from '@things-factory/id-rule-base'
-const { camelCase } = require('lodash')
-import moment from 'moment-timezone'
-
-import gql from 'graphql-tag'
-
-@EventSubscriber()
-export class EntityEventSubscriber implements EntitySubscriberInterface<any> {
-  async beforeInsert(event: InsertEvent<any>): Promise<any> {
-    let data = event.entity
-
-    if (!data) {
-      return
-    }
-
-    let entityName = event.metadata.name
-    let domainId = undefined
-
-    if (data.domainId) {
-      domainId = data.domainId
-    } else if (data.domain) {
-      domainId = data.domain.id
-    }
-
-    if (!domainId) {
-      return
-    }
-
-    let generateColumns = await this.findEntityColumns(domainId, entityName)
-
-    if (generateColumns && generateColumns.length > 0) {
-      for (let idx = 0; idx < generateColumns.length; idx++) {
-        let col = generateColumns[idx]
-        let colName = camelCase(col.name)
-
-        if (event.entity[colName]) {
-          continue
-        }
-
-        let seed = {
-          date: moment().format('YYYY-MM-DD'),
-          month: moment().format('YYYY-MM'),
-          year: moment().format('YYYY')
-        }
-
-        let genInfo = col.defVal.split(',')
-
-        for (let mapIdx = 1; mapIdx < genInfo.length; mapIdx++) {
-          let nameValue = genInfo[mapIdx].split(':')
-          let name: string = nameValue[0]
-          let value: string = nameValue[1]
-
-          seed[name] = value.indexOf('$') > -1 ? value.substring(1) : event.entity[value]
-        }
-
-        event.entity[colName] = await generateId({
-          domain: { id: domainId },
-          type: genInfo[0],
-          seed
-        })
-      }
-    }
-  }
-
-  async findEntityColumns(domainId: string, entityName: string): Promise<EntityColumn[]> {
-    let entity: Entity = await getRepository(Entity).findOne({
-      where: { domain: { id: domainId }, name: entityName },
-      relations: ['columns']
-    })
-
-    if (!entity) {
-      return undefined
-    }
-
-    return (entity.columns || []).filter(x => x.defVal)
-  }
-}

package/server/service/entity-event-subscriber/index.ts

@@ -1,3 +0,0 @@
-import { EntityEventSubscriber } from "./entity-event-subscriber";
-
-export const subscribers = [EntityEventSubscriber]

package/server/service/index.ts

@@ -1,41 +0,0 @@
-/* EXPORT ENTITY TYPES */
-export * from './button-role/button-role'
-export * from './menu-button-auth/menu-button-auth'
-export * from './work-code-detail/work-code-detail'
-export * from './work-code/work-code'
-
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as ButtonRoleEntities, resolvers as ButtonRoleResolvers } from './button-role'
-import { entities as MenuButtonAuthEntities, resolvers as MenuButtonAuthResolvers } from './menu-button-auth'
-import { resolvers as SetTranslationResolvers } from './set-translations'
-import { resolvers as MetaActivityResolvers } from './meta-activity'
-import { entities as WorkCodeDetailEntities, resolvers as WorkCodeDetailResolvers } from './work-code-detail'
-import { entities as WorkCodeEntities, resolvers as WorkCodeResolvers } from './work-code'
-import { resolvers as DynamicMenuResolvers } from './dynamic-menu'
-import { subscribers as EntityEventSubscriber } from './entity-event-subscriber'
-
-export const entities = [
-  /* ENTITIES */
-  ...ButtonRoleEntities,
-  ...MenuButtonAuthEntities,
-  ...WorkCodeDetailEntities,
-  ...WorkCodeEntities
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...ButtonRoleResolvers,
-    ...MenuButtonAuthResolvers,
-    ...SetTranslationResolvers,
-    ...MetaActivityResolvers,
-    ...WorkCodeDetailResolvers,
-    ...WorkCodeResolvers,
-    ...DynamicMenuResolvers
-  ]
-}
-
-export const subscribers = [
-  /* SUBSCRIBERS */
-  ...EntityEventSubscriber
-]

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

@@ -1,7 +0,0 @@
-
-import { MenuButtonAuth } from './menu-button-auth'
-import { MenuButtonAuthQuery } from './menu-button-auth-query'
-import { MenuButtonAuthMutation } from './menu-button-auth-mutation'
-
-export const entities = [MenuButtonAuth]
-export const resolvers = [MenuButtonAuthQuery, MenuButtonAuthMutation]

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

@@ -1,133 +0,0 @@
-
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { MenuButtonAuth } from './menu-button-auth'
-import { NewMenuButtonAuth, MenuButtonAuthPatch } from './menu-button-auth-type'
-import { Domain, getRepository, ScalarObject } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-@Resolver(MenuButtonAuth)
-export class MenuButtonAuthMutation {
-  @Directive('@transaction')
-  @Mutation(returns => MenuButtonAuth, { description: 'To create new MenuButtonAuth' })
-  async createMenuButtonAuth(@Arg('menuButtonAuth') menuButtonAuth: NewMenuButtonAuth, @Ctx() context: any): Promise<MenuButtonAuth> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(MenuButtonAuth).save({
-      ...menuButtonAuth,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => MenuButtonAuth, { description: 'To modify MenuButtonAuth information' })
-  async updateMenuButtonAuth(
-    @Arg('id') id: string,
-    @Arg('patch') patch: MenuButtonAuthPatch,
-    @Ctx() context: any
-  ): Promise<MenuButtonAuth> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(MenuButtonAuth)
-    const menuButtonAuth = await repository.findOne(
-      {
-        where: { domain: { id: domain.id }, id },
-        relations: ['domain','updater','creator']
-      }
-    )
-
-    return await repository.save({
-      ...menuButtonAuth,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [MenuButtonAuth], { description: "To modify multiple MenuButtonAuths' information" })
-  async updateMultipleMenuButtonAuth(
-    @Arg('patches', type => [MenuButtonAuthPatch]) patches: MenuButtonAuthPatch[],
-    @Ctx() context: any
-  ): Promise<MenuButtonAuth[]> {
-    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 menuButtonAuthRepo = tx.getRepository(MenuButtonAuth)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await menuButtonAuthRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updRecord = _updateRecords[i]
-        const menuButtonAuth = await menuButtonAuthRepo.findOne({
-          where: { domain: { id: domain.id }, id:updRecord.id },
-          relations: ['domain','updater','creator']
-        })
-        
-        const result = await menuButtonAuthRepo.save({
-          ...menuButtonAuth,
-          ...updRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [MenuButtonAuth], { description: "To modify multiple MenuButtonAuths' information" })
-  async updateMultipleMenuButtonAuths(
-    @Arg('patches', type => ScalarObject ) patches: any,
-    @Ctx() context: any
-  ): Promise<MenuButtonAuth[]> {
-    const { domain, user, tx } = context.state
-
-    console.log(patches)
-    return []
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete MenuButtonAuth' })
-  async deleteMenuButtonAuth(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { domain, tx, user } = context.state
-    await tx.getRepository(MenuButtonAuth).remove({ domain, id, updater:user })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple MenuButtonAuths' })
-  async deleteMenuButtonAuths(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: any
-  ): Promise<boolean> {
-    const { domain, tx, user } = context.state
-
-    let delEntitis = ids.map(id=>{
-      return {domain,id,updater:user}
-    })
-
-    await tx.getRepository(MenuButtonAuth).remove(delEntitis)
-
-    return true
-  }
-}

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

@@ -1,138 +0,0 @@
-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

@@ -1,63 +0,0 @@
-
-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

@@ -1,92 +0,0 @@
-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

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