@things-factory/meta-ui 8.0.0-beta.0 → 8.0.0-beta.2

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

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

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

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

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

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

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

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

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

@@ -1,147 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { WorkCodeDetail } from '../work-code-detail/work-code-detail'
-import { WorkCode } from './work-code'
-import { WorkCodePatch, NewWorkCode } from './work-code-type'
-
-@Resolver(WorkCode)
-export class WorkCodeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => WorkCode, { description: 'To create new WorkCode' })
-  async createWorkCode(
-    @Arg('workCode') workCode: NewWorkCode,
-    @Ctx() context: ResolverContext
-  ): Promise<WorkCode> {
-    const { domain, user, tx } = context.state
-
-    const details = await getRepository(WorkCodeDetail).findByIds(workCode.details || [])
-
-    return await tx.getRepository(WorkCode).save({
-      ...workCode,
-      details,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => WorkCode, { description: 'To modify WorkCode information' })
-  async updateWorkCode(
-    @Arg('patch') patch: WorkCodePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<WorkCode> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(WorkCode)
-    const workCode = await repository.findOne({
-      where: { id:patch.id },
-      relations: ['details']
-    })
-
-    const detailIds = workCode.details.map(detail => detail.id)
-    if (patch.details && patch.details.length) {
-      patch.details.forEach((detailId: string) => {
-        if (!detailIds.includes(detailId)) {
-          detailIds.push(detailId)
-        }
-      })
-    }
-
-    return await repository.save({
-      ...workCode,
-      ...patch,
-      details: await getRepository(WorkCodeDetail).findByIds(detailIds),
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [WorkCode], { description: "To modify multiple WorkCodes' information" })
-  async updateMultipleWorkCode(
-    @Arg('patches', type => [WorkCodePatch]) patches: WorkCodePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<WorkCode[]> {
-    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 commonCodeRepo = tx.getRepository(WorkCode)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await commonCodeRepo.save({
-          ...(newRecord as any),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const commonCode = await commonCodeRepo.findOneBy({ id: newRecord.id })
-
-        const result = await commonCodeRepo.save({
-          ...commonCode,
-          ...(newRecord as any),
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete WorkCode' })
-  async deleteWorkCode(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(WorkCode).delete({ id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple WorkCodes' })
-  async deleteWorkCodes(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(WorkCode).delete({id: In(ids)})
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple WorkCodes' })
-  async importWorkCodes(
-    @Arg('workCodes', type => [WorkCodePatch]) commonCodes: WorkCodePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      commonCodes.map(async (workCode: WorkCodePatch) => {
-        const createdWorkCode: WorkCode = await tx
-          .getRepository(WorkCode)
-          .save({ domain, ...(workCode as any) })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,67 +0,0 @@
-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 { WorkCodeDetail } from '../work-code-detail/work-code-detail'
-import { WorkCode } from './work-code'
-import { WorkCodeList } from './work-code-type'
-
-@Resolver(WorkCode)
-export class WorkCodeQuery {
-  @Query(returns => WorkCode!, { nullable: true, description: 'To fetch a WorkCode' })
-  async workCode(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<WorkCode> {
-    const { domain } = context.state
-
-    return await getRepository(WorkCode).findOne({
-      where: { id }
-    })
-  }
-
-  @Query(returns => WorkCode!, { nullable: true, description: 'To fetch a WorkCode' })
-  async workCodeByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<WorkCode> {
-    const { domain } = context.state
-
-    return await getRepository(WorkCode).findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-  }
-
-  @Query(returns => WorkCodeList, { description: 'To fetch multiple WorkCodes' })
-  async workCodes(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<WorkCodeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(WorkCode),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => [WorkCodeDetail])
-  async details(@Root() workCode: WorkCode): Promise<WorkCodeDetail[]> {
-    return await getRepository(WorkCodeDetail).findBy({
-      workCode: { id: workCode.id }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() workCode: WorkCode): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: workCode.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() workCode: WorkCode): Promise<User> {
-    return await getRepository(User).findOneBy({ id: workCode.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() workCode: WorkCode): Promise<User> {
-    return await getRepository(User).findOneBy({ id: workCode.creatorId })
-  }
-}

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

@@ -1,60 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { WorkCode } from './work-code'
-
-@InputType()
-export class NewWorkCode {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  category1?: string
-
-  @Field({ nullable: true })
-  category2?: string
-
-  @Field({ nullable: true })
-  category3?: string
-
-  @Field(type => [String], { nullable: true })
-  details?: string[]
-}
-
-@InputType()
-export class WorkCodePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  category1?: string
-
-  @Field({ nullable: true })
-  category2?: string
-
-  @Field({ nullable: true })
-  category3?: string
-
-  @Field(type => [String], { nullable: true })
-  details?: string[]
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class WorkCodeList {
-  @Field(type => [WorkCode])
-  items: WorkCode[]
-
-  @Field(type => Int)
-  total: number
-}