@things-factory/worklist 7.0.0-alpha.8 → 7.0.0

package/server/service/activity/activity-history.ts

@@ -1,187 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
-
-import {
-  HistoryActionColumn,
-  HistoryActionType,
-  HistoryEntityInterface,
-  HistoryOriginalIdColumn
-} from '@operato/typeorm-history'
-import { Role, User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
-import { ApprovalLineItem } from '@things-factory/organization'
-
-import { Activity, ActivityStartingType, ActivityStatus, ActivityType, ActivityUIType, AssigneeItem } from './activity'
-import { ActivityModelItem } from './activity-model-type'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_activity_history_0',
-  (activityHistory: ActivityHistory) => [activityHistory.originalId, activityHistory.version],
-  { unique: true }
-)
-@Index(
-  'ix_activity_history_1',
-  (activityHistory: ActivityHistory) => [activityHistory.domain, activityHistory.originalId, activityHistory.version],
-  { unique: true }
-)
-@ObjectType({ description: 'History Entity of Activity' })
-export class ActivityHistory implements HistoryEntityInterface<Activity> {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((activity: Activity) => activity.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  activityType?: ActivityType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ActivityStatus
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ActivityModelItem], { nullable: true })
-  model?: ActivityModelItem[]
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  priority?: number = 1
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  startingType?: ActivityStartingType
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  schedule?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  timezone?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  scheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  standardTime?: number
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  issuerRole?: Role
-
-  @RelationId((activity: Activity) => activity.issuerRole)
-  issuerRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  assigneeRole?: Role
-
-  @RelationId((activity: Activity) => activity.assigneeRole)
-  assigneeRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  supervisoryRole?: Role
-
-  @RelationId((activity: Activity) => activity.supervisoryRole)
-  supervisoryRoleId?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [AssigneeItem], { nullable: true, description: 'Who to resolve for the activity.' })
-  assignees?: AssigneeItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], {
-    nullable: true,
-    description: 'Approval line for handling the activity.'
-  })
-  approvalLine?: ApprovalLineItem[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of UI to be shown when a task is performed' })
-  uiType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of view to be shown when a task is approved' })
-  viewType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  viewSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of report to be shown when a task is approved' })
-  reportType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reportSource?: string
-
-  @Column()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator?: User
-
-  @RelationId((activity: Activity) => activity.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater?: User
-
-  @RelationId((activity: Activity) => activity.updater)
-  updaterId?: string
-
-  @HistoryOriginalIdColumn()
-  public originalId!: string
-
-  @HistoryActionColumn({
-    nullable: false,
-    type:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'enum'
-        : DATABASE_TYPE == 'oracle'
-        ? 'varchar2'
-        : 'smallint',
-    enum: HistoryActionType
-  })
-  public action!: HistoryActionType
-}

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

@@ -1,106 +0,0 @@
-import { Field, InputType, Int, ObjectType, registerEnumType } from 'type-graphql'
-
-import { ScalarObject } from '@things-factory/shell'
-
-export enum ActivityModelItemInoutType {
-  in = 'in',
-  out = 'out',
-  inout = 'inout'
-}
-
-registerEnumType(ActivityModelItemInoutType, {
-  name: 'ActivityModelItemInoutType',
-  description: 'inout enumeration of a activity-model-item'
-})
-
-export enum ActivityModelItemType {
-  number = 'number',
-  text = 'text',
-  textarea = 'textarea',
-  boolean = 'boolean',
-  select = 'select',
-  file = 'file'
-}
-
-registerEnumType(ActivityModelItemType, {
-  name: 'ActivityModelItemType',
-  description: 'data type enumeration of a activity-model-item'
-})
-
-@ObjectType({ description: 'Entity for ActivityModelItem' })
-export class ActivityModelItem {
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  tag?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  hidden?: boolean
-
-  @Field({ nullable: true })
-  mandatory?: boolean
-
-  @Field(type => ActivityModelItemInoutType, { nullable: true })
-  inout?: ActivityModelItemInoutType
-
-  @Field({ nullable: true })
-  type?: ActivityModelItemType
-
-  @Field(type => ScalarObject, { nullable: true })
-  options?: { [option: string]: any }
-
-  @Field({ nullable: true })
-  unit?: string
-
-  @Field(type => [Int], { nullable: true })
-  quantifier?: number[]
-
-  @Field(type => ScalarObject, { nullable: true })
-  spec?: { [key: string]: any }
-}
-
-@InputType()
-export class ActivityModelItemPatch {
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  tag?: string
-
-  @Field(type => ActivityModelItemInoutType, { nullable: true })
-  inout?: ActivityModelItemInoutType
-
-  @Field(type => ActivityModelItemType, { nullable: true })
-  type?: ActivityModelItemType
-
-  @Field(type => ScalarObject, { nullable: true })
-  options?: { [option: string]: any }
-
-  @Field({ nullable: true })
-  unit?: string
-
-  @Field(type => [Int], { nullable: true })
-  quantifier: number[]
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  mandatory?: boolean
-
-  @Field({ nullable: true })
-  hidden?: boolean
-
-  @Field(type => ScalarObject, { nullable: true })
-  spec?: { [key: string]: any }
-}

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

@@ -1,388 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { Application, CallbackBase, registerSchedule, unregisterSchedule } from '@things-factory/scheduler-client'
-import { ApprovalLineItem, OrgMemberTargetType } from '@things-factory/organization'
-
-import { Activity, AssigneeItem } from './activity'
-import { ActivityPatch, NewActivity } from './activity-type'
-
-function getApprovalLineValue(patch: NewActivity | ActivityPatch): ApprovalLineItem[] {
-  const { approvalLine } = patch
-
-  if (!('approvalLine' in patch)) {
-    /* approvalLine이 언급되지 않았다면, 업데이트하지 않는다. */
-    return
-  }
-
-  if (!approvalLine || !(approvalLine instanceof Array)) {
-    /* approvalLine의 값이 없거나 배열이 아니라면, 클리어시킨다. */
-    return null
-  }
-
-  return approvalLine
-    .map(m => {
-      return {
-        type: m.type,
-        approver: m.approver
-      } as ApprovalLineItem
-    })
-    .filter(m => m.type)
-    .filter(m => {
-      switch (m.type) {
-        case OrgMemberTargetType.Employee:
-        case OrgMemberTargetType.Department:
-        case OrgMemberTargetType.Role:
-          return !!m.approver?.id
-        default:
-          return true
-      }
-    })
-}
-
-function getAssigneesValue(patch: NewActivity | ActivityPatch): AssigneeItem[] {
-  const { assignees } = patch
-
-  if (!('assignees' in patch)) {
-    /* assignees이 언급되지 않았다면, 업데이트하지 않는다. */
-    return
-  }
-
-  if (!assignees || !(assignees instanceof Array)) {
-    /* assignees의 값이 없거나 배열이 아니라면, 클리어시킨다. */
-    return null
-  }
-
-  return assignees
-    .map(m => {
-      return {
-        type: m.type,
-        assignee: m.assignee
-      } as ApprovalLineItem
-    })
-    .filter(m => m.type)
-    .filter(m => {
-      switch (m.type) {
-        case OrgMemberTargetType.Employee:
-        case OrgMemberTargetType.Department:
-        case OrgMemberTargetType.Role:
-          return !!m.assignee?.id
-        default:
-          return true
-      }
-    })
-}
-
-@Resolver(Activity)
-export class ActivityMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Activity, { description: 'To create new Activity' })
-  async createActivity(@Arg('activity') activity: NewActivity, @Ctx() context: ResolverContext): Promise<Activity> {
-    const { domain, user, tx } = context.state
-
-    const result = await tx.getRepository(Activity).save({
-      ...activity,
-      assignees: getAssigneesValue(activity),
-      approvalLine: getApprovalLineValue(activity),
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    if (activity.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: activity.thumbnail,
-            refType: Activity.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Activity, { description: 'To modify Activity information' })
-  async updateActivity(
-    @Arg('id') id: string,
-    @Arg('patch') patch: ActivityPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Activity> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Activity)
-    const activity = await repository.findOne({
-      where: { domain: { id: domain.id }, id },
-      /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
-      relations: ['domain', 'issuerRole', 'assigneeRole', 'supervisoryRole', 'creator', 'updater']
-    })
-
-    const result = await repository.save({
-      ...activity,
-      ...patch,
-      assignees: getAssigneesValue(activity),
-      approvalLine: getApprovalLineValue(activity),
-      updater: user
-    })
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: Activity.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => [Activity], { description: "To modify multiple Activities' information" })
-  async updateMultipleActivity(
-    @Arg('patches', type => [ActivityPatch]) patches: ActivityPatch[],
-    @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]
-
-        const result = await activityRepo.save({
-          ...newRecord,
-          assignees: getAssigneesValue(newRecord),
-          approvalLine: getApprovalLineValue(newRecord),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: Activity.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const activity = await activityRepo.findOne({
-          where: { id: updateRecord.id },
-          /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
-          relations: ['domain', 'issuerRole', 'assigneeRole', 'supervisoryRole', 'creator', 'updater']
-        })
-
-        const result = await activityRepo.save({
-          ...activity,
-          ...updateRecord,
-          assignees: getAssigneesValue(updateRecord),
-          approvalLine: getApprovalLineValue(updateRecord),
-          updater: user
-        })
-
-        if (updateRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: updateRecord.thumbnail,
-                refType: Activity.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete Activity' })
-  async deleteActivity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Activity).delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Activities' })
-  async deleteActivities(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Activity).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple Activities' })
-  async importActivities(
-    @Arg('activities', type => [ActivityPatch]) activities: ActivityPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      activities.map(async (activity: ActivityPatch) => {
-        const createdActivity: Activity = await tx.getRepository(Activity).save({ domain, ...activity })
-      })
-    )
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Activity, {
-    description: 'To start posting activity based on the schedule of the given activity'
-  })
-  async startActivitySchedule(
-    @Arg('activityId') activityId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Activity> {
-    const { domain, tx } = context.state
-
-    var repository = tx.getRepository(Activity)
-    var activity = await repository.findOne({
-      where: { domain: { id: domain.id }, id: activityId }
-    })
-
-    if (!activity) {
-      throw new Error(
-        context.t('error.activity not found', {
-          activity: activityId
-        })
-      )
-    }
-
-    try {
-      var handle = await registerSchedule({
-        name: activity.name,
-        client: {
-          application: Application,
-          group: `${domain.id}`,
-          type: 'activity',
-          key: activity.id,
-          operation: 'schedule'
-        },
-        type: 'cron',
-        schedule: activity.schedule,
-        timezone: activity.timezone,
-        task: {
-          type: 'rest',
-          connection: {
-            host: `${CallbackBase}/callback-schedule-for-activity`,
-            headers: {
-              'Content-Type': 'application/json',
-              accept: '*/*'
-            }
-          },
-          data: {
-            domainId: domain.id,
-            activityId
-          },
-          history_check: true,
-          failed_policy: 'retry_dlq',
-          max_retry_count: 3,
-          retry_period: 60
-        }
-      })
-
-      return await repository.save({
-        ...activity,
-        scheduleId: handle
-      })
-    } catch (err) {
-      console.error('startActivitySchedule', err)
-    }
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "activity", privilege: "mutation", domainOwnerGranted: true)')
-  @Mutation(returns => Activity, {
-    nullable: true,
-    description: 'To stop posting activity based on the schedule of the given activity'
-  })
-  async stopActivitySchedule(
-    @Arg('activityId') activityId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Activity | undefined> {
-    const { domain, tx } = context.state
-
-    var repository = tx.getRepository(Activity)
-    var activity = await repository.findOne({
-      where: { domain: { id: domain.id }, id: activityId }
-    })
-
-    if (!activity) {
-      throw new Error(
-        context.t('error.activity not found', {
-          activity: activityId
-        })
-      )
-    }
-
-    try {
-      await unregisterSchedule(activity.scheduleId)
-
-      return await repository.save({
-        ...activity,
-        scheduleId: null
-      })
-    } catch (err) {
-      console.error('stopActivitySchedule', err)
-    }
-  }
-}