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

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

@@ -0,0 +1,270 @@
+import { Resolver, FieldResolver, Root, Query, Args, Ctx, Arg } from 'type-graphql'
+import { ListParam, getRepository, getQueryBuilderFromListParams } from '@things-factory/shell'
+import { Menu } from '@things-factory/menu-base'
+
+import { DynamicMenuList, ExportMenuInfo } from './dynamic-menu-type'
+
+import { Entity, EntityColumn } from '@things-factory/resource-base'
+
+import crypto from 'crypto'
+const { camelCase, startCase, snakeCase, kebabCase, upperFirst } = require('lodash')
+
+@Resolver(Menu)
+export class DynamicMenuQuery {
+  @Query(returns => ExportMenuInfo, { description: 'To fetch a export menu data' })
+  async exportMenuInfo(@Arg('id') id: string, @Ctx() context: any): Promise<ExportMenuInfo> {
+    const { domain } = context.state
+
+    // 메뉴
+    const menu: Menu = await getRepository(Menu).findOneBy({ id: id, domain: { id: domain.id } })
+    const parentMenu: Menu = await getRepository(Menu).findOneBy({ id: menu.parentId, domain: { id: domain.id } })
+
+    // entity
+    let entityName = upperFirst(camelCase(menu.routing))
+    const entity: Entity = await getRepository(Entity).findOneBy({ domain: { id: domain.id }, name: entityName })
+
+    // entity Columns
+    const entityColumns: EntityColumn[] = await getRepository(EntityColumn).findBy({
+      domain: { id: domain.id },
+      entity: { id: entity.id }
+    })
+
+    let entityMeta = getRepository(entityName).metadata
+
+    const indices = entityMeta.indices.map(x => {
+      return {
+        name: x.name,
+        isUnique: x.isUnique,
+        columns: x.columns.map(y => {
+          return y.databaseName.toUpperCase()
+        })
+      }
+    })
+
+    const columns = entityMeta.columns
+      .map(x => {
+        return {
+          name: x.databaseName,
+          isNullable: x.isNullable,
+          length: x.type == 'numeric' ? [x.precision, x.scale].join(',') : x.length,
+          type: x.type.toString(),
+          default: typeof x.default === 'function' ? undefined : x.default
+        }
+      })
+      .filter(x => ['data_revision_no', 'deleted_at'].includes(x.name) == false)
+
+    return {
+      id,
+      menu,
+      entity,
+      entityColumns,
+      indices,
+      columns,
+      parentMenu
+    }
+  }
+
+  @Query(returns => DynamicMenuList, { description: 'To fetch multiple dynamicMenus' })
+  async dynamicMenus(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<DynamicMenuList> {
+    const { domain } = context.state
+
+    let templateCodeIdx = params.filters?.findIndex(x => x.name == 'templateCode')
+    let templateCode = undefined
+
+    if (templateCodeIdx > -1) {
+      templateCode = params.filters[templateCodeIdx].value
+      params.filters = params.filters.filter(x => x.name != 'templateCode')
+    }
+
+    let templateTextIdx = params.filters?.findIndex(x => x.name == 'templateText')
+    let templateText = undefined
+
+    if (templateTextIdx > -1) {
+      templateText = params.filters[templateTextIdx].value
+      params.filters = params.filters.filter(x => x.name != 'templateText')
+    }
+
+    if (templateText) {
+      params.pagination.limit = 0
+      params.pagination.page = 0
+    }
+
+    let groupSearch =
+      params.filters?.findIndex(x => x.name == 'parentId' && x.operator == 'is_null') > -1 ? true : false
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Menu),
+      searchables: ['name', 'description', 'routing']
+    })
+
+    let [items, total] = await queryBuilder.getManyAndCount()
+    let result: DynamicMenuList = { items: items, total: total }
+
+    let self = this
+
+    if (templateText) {
+      if (groupSearch === true) {
+        for (let idx = 0; idx < result.items.length; idx++) {
+          result.items[idx].children = await getRepository(Menu).findBy({ parent: { id: result.items[idx].id } })
+        }
+      }
+
+      items = items.filter(function (item: Menu) {
+        return self.checkTemplateByContainsText(
+          templateCode,
+          templateText,
+          groupSearch === true ? item.children : item.template
+        )
+      })
+    }
+
+    return {
+      items,
+      total
+    }
+  }
+
+  checkTemplate(code: string, text: string, template: string) {
+    if (!template) return false
+
+    let templateString: any = ''
+    let templateJsonStr = this.dec(template)
+    let templateJson = JSON.parse(templateJsonStr)
+
+    if (code === 'col-name') {
+      templateString = templateJson['grid_column'].map(x => {
+        return x.name
+      })
+    } else if (code === 'object-custom') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(
+            x =>
+              ['meta-object-selector', 'object', 'resource-object'].includes(x.type) &&
+              x.object_opt &&
+              !x.object_opt.menu
+          )
+          .map(x => {
+            return x.object_opt
+          })
+      )
+    } else if (code === 'object-menu') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(
+            x =>
+              ['meta-object-selector', 'object', 'resource-object'].includes(x.type) &&
+              x.object_opt &&
+              x.object_opt.menu
+          )
+          .map(x => {
+            return x.object_opt.menu
+          })
+      )
+    } else if (code === 'code-custom') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(
+            x => ['meta-code-selector', 'resource-code-selector'].includes(x.type) && x.object_opt && !x.object_opt.menu
+          )
+          .map(x => {
+            return x.object_opt
+          })
+      )
+    } else if (code === 'code-menu') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(
+            x => ['meta-code-selector', 'resource-code-selector'].includes(x.type) && x.object_opt && x.object_opt.menu
+          )
+          .map(x => {
+            return x.object_opt.menu
+          })
+      )
+    } else if (code === 'selector-entity') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(x => x.type == 'select' && x.select_opt && x.select_opt.type == 'entity')
+          .map(x => {
+            return x.select_opt
+          })
+      )
+    } else if (code === 'selector-code') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(x => x.type == 'select' && x.select_opt && x.select_opt.type == 'code')
+          .map(x => {
+            return x.select_opt.name
+          })
+      )
+    } else if (code === 'selector-scenario') {
+      templateString = JSON.stringify(
+        templateJson['grid_column']
+          .filter(x => x.type == 'select' && x.select_opt && x.select_opt.type == 'scenario')
+          .map(x => {
+            return x.select_opt.name
+          })
+      )
+    } else {
+      templateString = templateJsonStr
+    }
+
+    return templateString.includes(text)
+  }
+
+  checkTemplateByContainsText(code: string, text: string, template: any) {
+    if (Array.isArray(template)) {
+      for (let idx = 0; idx < template.length; idx++) {
+        let contains = this.checkTemplate(code, text, template[idx].template)
+
+        if (contains == true) {
+          return true
+        }
+      }
+
+      return false
+    } else {
+      return this.checkTemplate(code, text, template)
+    }
+  }
+
+  dec(template: string): string {
+    let decResults = []
+    let encTemps = template.split('h1z0q9i9x7q6')
+    let filters = [
+      'aes-256-ecb',
+      'aes-256-cbc',
+      'aes-256-cfb',
+      'aes-256-cfb8',
+      'aes-256-cfb1',
+      'aes-256-ofb',
+      'aes-256-ctr',
+      'aes256'
+    ]
+    let salt = encTemps[0]
+    let hexKey = Buffer.from(salt, 'hex')
+    let ivBase = salt.substring(0, 16)
+    let iv = ['', ivBase, ivBase, ivBase, ivBase, ivBase, ivBase, ivBase]
+    let filterIdx = 0
+
+    encTemps = encTemps.splice(1)
+
+    for (var i = 0; i < encTemps.length; i++, filterIdx++) {
+      if (filterIdx == filters.length) filterIdx = 0
+
+      let decipher = crypto.createDecipheriv(filters[filterIdx], hexKey, iv[filterIdx])
+      let decrypted = decipher.update(encTemps[i], 'hex', 'utf8')
+      decrypted += decipher.final('utf8')
+
+      decResults.push(decrypted)
+    }
+    return JSON.parse(decResults.join(''))
+  }
+
+  @FieldResolver(type => Menu)
+  async parent(@Root() menu: Menu): Promise<Menu> {
+    return await getRepository(Menu).findOneBy({ id: menu.parentId })
+  }
+}

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

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

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

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

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

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

package/server/service/index.ts

@@ -0,0 +1,41 @@
+/* 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

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

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