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

package/server/activity/CommonActivity.ts

@@ -1,68 +0,0 @@
-import { ActivityInstance, /* post, */ UpdateActivityInstanceStateAddendum } from '@things-factory/worklist'
-import { Scenario } from '@things-factory/integration-base'
-import { getRepository, GraphqlLocalClient } from '@things-factory/shell'
-
-import gql from 'graphql-tag'
-
-export async function callback(
-  activityInstance: ActivityInstance,
-  addendum: UpdateActivityInstanceStateAddendum,
-  context: ResolverContext
-) {
-  const { domain } = context.state
-  const { causedBy } = addendum || {}
-
-  let instanceName = ''
-  let scenarioName = `${activityInstance.activity.name}-activity-callback`
-
-  if ((await existsScenario(domain, scenarioName)) == false) {
-    return
-  }
-
-  let variables = {
-    activityInstance,
-    causedBy
-    /* post */
-  }
-
-  await runScenario(context, instanceName, scenarioName, variables)
-}
-
-async function existsScenario(domain: any, scenarioName: string): Promise<Boolean> {
-  var repository = getRepository(Scenario)
-  var scenario = await repository.findOne({
-    where: { domain: { id: domain.id }, name: scenarioName },
-    relations: ['domain', 'steps', 'creator', 'updater']
-  })
-
-  if (!scenario) {
-    return false
-  }
-  return true
-}
-
-async function runScenario(context: any, instanceName: String, scenarioName: String, variables: any): Promise<void> {
-  // await ScenarioInstanceMutation.runScenario(instanceName,scenarioName,variables,context);
-  var client = GraphqlLocalClient.client
-
-  await client.mutate({
-    mutation: gql`
-      mutation ($instanceName: String, $scenarioName: String!, $variables: Object) {
-        runScenario(instanceName: $instanceName, scenarioName: $scenarioName, variables: $variables) {
-          instanceName
-          scenarioName
-          state
-          result
-          message
-          timestamp
-        }
-      }
-    `,
-    variables: {
-      instanceName,
-      scenarioName,
-      variables
-    },
-    context
-  })
-}

package/server/index.ts

@@ -1,3 +0,0 @@
-import './routes'
-
-export * from './service'

package/server/routes.ts

@@ -1,61 +0,0 @@
-import { ActivityInstallations, Activity, ActivityStatus } from '@things-factory/worklist'
-import { getRepository } from '@things-factory/shell'
-import { callback } from './activity/CommonActivity'
-const path = require('path')
-const { appRootPath } = require('@things-factory/env')
-const AppPackage = require(path.resolve(appRootPath, 'package.json'))
-
-process.on('bootstrap-module-global-public-route' as any, async (app: any, globalPublicRouter) => {
-  /*
-   * can add global public routes to application (auth not required, tenancy not required)
-   *
-   * ex) routes.get('/path', async(context, next) => {})
-   * ex) routes.post('/path', async(context, next) => {})
-   */
-
-  const releaseActivityTemplates: Activity[] = await getRepository(Activity).find({
-    where: { 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
-      })
-    }
-  })
-})
-
-process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
-  /*
-   * can add global private routes to application (auth required, tenancy not required)
-   */
-})
-
-process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
-  /*
-   * can add domain public routes to application (auth not required, tenancy required)
-   */
-})
-
-process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
-  /*
-   * can add domain private routes to application (auth required, tenancy required)
-   */
-})

package/server/service/button-role/button-role-mutation.ts

@@ -1,105 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { ButtonRole } from './button-role'
-import { NewButtonRole, ButtonRolePatch } from './button-role-type'
-
-@Resolver(ButtonRole)
-export class ButtonRoleMutation {
-  @Directive('@transaction')
-  @Mutation(returns => ButtonRole, { description: 'To create new ButtonRole' })
-  async createButtonRole(@Arg('buttonRole') buttonRole: NewButtonRole, @Ctx() context: any): Promise<ButtonRole> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(ButtonRole).save({
-      ...buttonRole,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ButtonRole, { description: 'To modify ButtonRole information' })
-  async updateButtonRole(@Arg('id') id: string, @Arg('patch') patch: ButtonRolePatch, @Ctx() context: any): Promise<ButtonRole> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(ButtonRole)
-    const buttonRole = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['domain', 'updater', 'creator']
-    })
-
-    return await repository.save({
-      ...buttonRole,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [ButtonRole], { description: "To modify multiple buttonRoles' information" })
-  async updateMultipleButtonRole(@Arg('patches', type => [ButtonRolePatch]) patches: ButtonRolePatch[], @Ctx() context: any): Promise<ButtonRole[]> {
-    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 buttonRoleRepo = tx.getRepository(ButtonRole)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await buttonRoleRepo.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 buttonRole = await buttonRoleRepo.findOne({
-          where: { domain: { id: domain.id }, id: updRecord.id },
-          relations: ['domain', 'updater', 'creator']
-        })
-
-        const result = await buttonRoleRepo.save({
-          ...buttonRole,
-          ...updRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete ButtonRole' })
-  async deleteButtonRole(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
-    const { domain, tx, user } = context.state
-    await tx.getRepository(ButtonRole).remove({ domain, id, updater: user })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple ButtonRoles' })
-  async deleteButtonRoles(@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(ButtonRole).remove(delEntitis)
-
-    return true
-  }
-}

package/server/service/button-role/button-role-query.ts

@@ -1,53 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import {
-  Domain,
-  ListParam,
-  convertListParams,
-  getRepository,
-  getQueryBuilderFromListParams
-} from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { ButtonRole } from './button-role'
-import { ButtonRoleList } from './button-role-type'
-
-@Resolver(ButtonRole)
-export class ButtonRoleQuery {
-  @Query(returns => ButtonRole, { description: 'To fetch a ButtonRole' })
-  async buttonRole(@Arg('id') id: string, @Ctx() context: any): Promise<ButtonRole> {
-    const { domain } = context.state
-    return await getRepository(ButtonRole).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => ButtonRoleList, { description: 'To fetch a multiple ButtonRole' })
-  async buttonRoles(@Args(type => ListParam) params: ListParam, @Ctx() context: any): Promise<ButtonRoleList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(ButtonRole),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() buttonRole: ButtonRole): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: buttonRole.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() buttonRole: ButtonRole): Promise<User> {
-    return await getRepository(User).findOneBy({ id: buttonRole.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() buttonRole: ButtonRole): Promise<User> {
-    return await getRepository(User).findOneBy({ id: buttonRole.creatorId })
-  }
-}

package/server/service/button-role/button-role-type.ts

@@ -1,39 +0,0 @@
-
-import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
-import { ObjectRef } from '@things-factory/shell'
-
-import { ButtonRole } from './button-role'
-
-@InputType()
-export class NewButtonRole {
-
-  @Field({ nullable: false })
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@InputType()
-export class ButtonRolePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class ButtonRoleList {
-  @Field(type => [ButtonRole])
-  items: ButtonRole[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/button-role/button-role.ts

@@ -1,61 +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'
-
-@Entity('button_roles')
-@Index('ix_button_role_0', (buttonRole: ButtonRole) => [buttonRole.domain, buttonRole.name], { unique: true })
-@ObjectType({ description: 'Entity for ButtonRole' })
-export class ButtonRole {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ name: 'name', type: 'character varying', length: 100, nullable: false })
-  @Field({ nullable: false })
-  name: string
-
-  @Column({ name: 'description', type: 'character varying', length: 255, nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: false })
-  domain: Domain
-
-  @RelationId((buttonRole: ButtonRole) => buttonRole.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((buttonRole: ButtonRole) => buttonRole.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { createForeignKeyConstraints: false, nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((buttonRole: ButtonRole) => buttonRole.updater)
-  updaterId?: string
-}

package/server/service/button-role/index.ts

@@ -1,7 +0,0 @@
-
-import { ButtonRole } from './button-role'
-import { ButtonRoleQuery } from './button-role-query'
-import { ButtonRoleMutation } from './button-role-mutation'
-
-export const entities = [ButtonRole]
-export const resolvers = [ButtonRoleQuery, ButtonRoleMutation]

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

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