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

package/server/controllers/activity-thread/restart.ts

@@ -1,51 +0,0 @@
-import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
-import { updateActivityInstanceState } from '../common'
-
-export async function restart(id: string, output: object, reason: string, context: ResolverContext): Promise<ActivityThread> {
-  const { domain, user, tx } = context.state
-
-  const repository = tx.getRepository(ActivityThread)
-  const activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id }
-  })
-
-  if (!activityThread) {
-    throw new Error(
-      context.t('error.activity-thread not found', {
-        activityThread: id
-      })
-    )
-  }
-
-  /* 
-    Prerequisites for a activity thread to Be Delegated.
-    - The previous state of the activity thread should be Rejected.
-  */
-  if (activityThread.state !== ActivityThreadStatus.Rejected) {
-    throw new Error(
-      context.t(`error.activity-thread should be the state`, {
-        id,
-        state: ActivityThreadStatus.Rejected,
-        actual: activityThread.state
-      })
-    )
-  }
-
-  if (output) {
-    activityThread.output = output
-  }
-
-  const result = await tx.getRepository(ActivityThread).save({
-    ...activityThread,
-    reason,
-    state: ActivityThreadStatus.Started,
-    transaction: 'restart',
-    round: activityThread.round + 1,
-    updater: user,
-    startedAt: new Date()
-  })
-
-  await updateActivityInstanceState(activityThread.activityInstanceId, { causedBy: [result] }, context)
-
-  return result
-}

package/server/controllers/activity-thread/save.ts

@@ -1,50 +0,0 @@
-import { ActivityThreadSave } from '../../service/activity-thread/activity-thread-type'
-import { updateActivityInstanceState } from '../common'
-import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
-
-export async function save(id: string, save: ActivityThreadSave, reason: string, context: ResolverContext): Promise<ActivityThread> {
-  const { domain, user, tx } = context.state
-  const repository = tx.getRepository(ActivityThread)
-
-  var activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id }
-  })
-
-  if (!activityThread) {
-    throw new Error(
-      context.t('error.activity-thread not found', {
-        activityThread: id
-      })
-    )
-  }
-
-  /* 
-    Prerequisites for a activity thread to Be Saved.
-    - The previous state of the activity thread must not be terminated.
-  */
-  if (activityThread.state == ActivityThreadStatus.Aborted || activityThread.state == ActivityThreadStatus.Ended) {
-    throw new Error(
-      context.t(`error.activity-thread is already terminated`, {
-        id,
-        actual: activityThread.state
-      })
-    )
-  }
-
-  if (!activityThread.startedAt) {
-    /* The act of saving means automatically starting the work. */
-    activityThread.startedAt = new Date()
-  }
-
-  activityThread = await repository.save({
-    ...activityThread,
-    ...save,
-    state: ActivityThreadStatus.Started,
-    transaction: 'save',
-    updater: user
-  })
-
-  await updateActivityInstanceState(activityThread.activityInstanceId, { causedBy: [activityThread] }, context)
-
-  return activityThread
-}

package/server/controllers/activity-thread/start.ts

@@ -1,49 +0,0 @@
-import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
-import { updateActivityInstanceState } from '../common'
-
-export async function start(id: string, output: object, reason: string, context: ResolverContext): Promise<ActivityThread> {
-  const { domain, user, tx } = context.state
-
-  const repository = tx.getRepository(ActivityThread)
-  const activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id }
-  })
-
-  if (!activityThread) {
-    throw new Error(
-      context.t('error.activity-thread not found', {
-        activityThread: id
-      })
-    )
-  }
-
-  /* 
-    Prerequisites for a activity thread to Be Started.
-    - The previous state of the activity thread must not be terminated.
-  */
-  if (activityThread.state !== ActivityThreadStatus.Assigned) {
-    throw new Error(
-      context.t(`error.activity-thread should not be started`, {
-        id,
-        actual: activityThread.state
-      })
-    )
-  }
-
-  if (output) {
-    activityThread.output = output
-  }
-
-  const result = await tx.getRepository(ActivityThread).save({
-    ...activityThread,
-    reason,
-    state: ActivityThreadStatus.Started,
-    transaction: 'start',
-    updater: user,
-    startedAt: new Date()
-  })
-
-  await updateActivityInstanceState(activityThread.activityInstanceId, { causedBy: [result] }, context)
-
-  return result
-}

package/server/controllers/activity-thread/submit.ts

@@ -1,89 +0,0 @@
-import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
-import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
-import { getSystemUserFromOrgMemberItem, updateActivityInstanceState } from '../common'
-import { ApprovalLineItem } from '@things-factory/organization'
-
-export async function submit({ id, output, reason }: { id: string; output?: object; reason?: string }, context: ResolverContext): Promise<ActivityThread> {
-  const { domain, user, tx } = context.state
-
-  // TODO - output값 체크해서 필수필드, validation 을 만족하지 못하면, Error를 던진다.
-  // 필수 필드가 빈 값인 경우나, validation 이 있는 경우에 체크하여 false가 되는 경우.
-
-  const repository = tx.getRepository(ActivityThread)
-
-  var activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['activityInstance']
-  })
-
-  if (!activityThread) {
-    throw new Error(
-      context.t('error.activity-thread not found', {
-        activityThread: id
-      })
-    )
-  }
-
-  /* 
-    Prerequisites for a activity thread to Be Started.
-    - The previous state of the activity thread must not be terminated.
-  */
-  if (activityThread.state !== ActivityThreadStatus.Assigned && activityThread.state !== ActivityThreadStatus.Started) {
-    throw new Error(
-      context.t(`error.activity-thread should not be submitted`, {
-        id,
-        actual: activityThread.state
-      })
-    )
-  }
-
-  if (!activityThread.startedAt) {
-    activityThread.startedAt = new Date()
-  }
-
-  const approvalLine: ApprovalLineItem[] = activityThread.activityInstance.approvalLine
-
-  if (approvalLine && approvalLine.length > 0) {
-    var approverUser = await getSystemUserFromOrgMemberItem(approvalLine[0], context)
-
-    if (!approverUser) {
-      throw 'Cannot specify the approval user for this approval line'
-    }
-
-    await tx.getRepository(ActivityApproval).save({
-      domain,
-      activityThread,
-      round: activityThread.round,
-      order: 1,
-      judgment: ActivityApprovalJudgment.Pending,
-      transaction: 'submit',
-      approver: approverUser,
-      creator: user,
-      updater: user
-    })
-
-    activityThread = await repository.save({
-      ...activityThread,
-      reason,
-      output,
-      transaction: 'submit',
-      state: ActivityThreadStatus.Submitted,
-      updater: user
-    })
-  } else {
-    activityThread = await repository.save({
-      ...activityThread,
-      reason,
-      output,
-      transaction: 'end',
-      state: ActivityThreadStatus.Ended,
-      updater: user,
-      terminator: user,
-      terminatedAt: new Date()
-    })
-  }
-
-  await updateActivityInstanceState(activityThread.activityInstanceId, { causedBy: [activityThread] }, context)
-
-  return activityThread
-}

package/server/controllers/common.ts

@@ -1,311 +0,0 @@
-import { Role, User } from '@things-factory/auth-base'
-
-import { ActivitySearchKeyItem } from '../service/activity/activity-search-key-item-type'
-import { AssigneeItem, MultipleInstanceType } from '../service/activity/activity'
-import { ActivityInstance, ActivityInstanceStatus } from '../service/activity-instance/activity-instance'
-import { ActivityThread, ActivityThreadStatus } from '../service/activity-thread/activity-thread'
-import { Department, Employee, ApprovalLineItem, OrgMemberTargetType } from '@things-factory/organization'
-import { ActivityInstallations } from './activity-installation/activity-installation-controller'
-
-export type UpdateActivityInstanceStateAddendum = {
-  causedBy?: ActivityThread[]
-}
-
-export async function updateActivityInstanceState(
-  id: string,
-  { causedBy }: UpdateActivityInstanceStateAddendum,
-  context: ResolverContext
-) {
-  const { tx } = context.state
-
-  var activityInstance = await tx.getRepository(ActivityInstance).findOne({
-    where: { id },
-    relations: [
-      'domain',
-      'activity',
-      'activityThreads',
-      'assigneeRole',
-      'supervisoryRole',
-      'updater',
-      'creator',
-      'starter',
-      'terminator'
-    ]
-  })
-
-  activityInstance.transaction = 'thread' /* activity thread에 의해서 변경된 것임을 의미 */
-  Object.assign(activityInstance, await evalActivityInstanceState(id, context))
-
-  /* callback에서 업무적인 처리도 하고, activityInstance를 일부(주로 input) 수정할 수 있는 기회도 제공. */
-  await ActivityInstallations.callback(activityInstance.activity.name, activityInstance, causedBy, context)
-
-  await tx.getRepository(ActivityInstance).save(activityInstance)
-}
-
-export async function evalActivityInstanceState(
-  id: string,
-  context: ResolverContext
-): Promise<Partial<ActivityInstance>> {
-  const { tx, user } = context.state
-
-  const activityInstance = await tx.getRepository(ActivityInstance).findOne({
-    where: { id },
-    relations: ['activityThreads', 'activity']
-  })
-  const { threadsMin, activityThreads, state, dueAt } = activityInstance
-
-  const validThreads = activityThreads.filter(thread => thread.isValid())
-  const pendingStartedThreads = activityThreads.filter(thread => thread.isPendingStarted())
-  const pendingEndedThreads = activityThreads.filter(thread => thread.isPendingEnded())
-
-  switch (true) {
-    case state === ActivityInstanceStatus.Draft:
-    case state === ActivityInstanceStatus.Ended:
-    case state === ActivityInstanceStatus.Aborted:
-      return {}
-    case validThreads.length === 0:
-      return {
-        state: ActivityInstanceStatus.Issued
-      }
-    case threadsMin > validThreads.length:
-      return {
-        state: ActivityInstanceStatus.PendingAssignment
-      }
-    case pendingStartedThreads.length > 0:
-      return {
-        state: ActivityInstanceStatus.Assigned,
-        assignedAt: new Date()
-      }
-    case pendingEndedThreads.length > 0:
-      var started = !dueAt || dueAt.getTime() > Date.now()
-      var changed =
-        (started && state !== ActivityInstanceStatus.Started) || (!started && state !== ActivityInstanceStatus.Pending)
-
-      return !changed
-        ? null
-        : started
-        ? {
-            state: ActivityInstanceStatus.Started,
-            startedAt: new Date(),
-            starter: user
-          }
-        : {
-            state: ActivityInstanceStatus.Pending
-          }
-    default:
-      return {
-        state: activityThreads.some(thread => thread.state == ActivityThreadStatus.Aborted)
-          ? ActivityInstanceStatus.Aborted
-          : ActivityInstanceStatus.Ended,
-        reason: '',
-        output: [MultipleInstanceType.Parallel, MultipleInstanceType.Sequential].includes(
-          activityInstance.activity.multiple
-        )
-          ? activityThreads
-              .filter(thread => (thread.state = ActivityThreadStatus.Ended))
-              .reduce((sum, thread) => {
-                sum[thread.assigneeId] = thread.output
-                return sum
-              }, {} as any)
-          : activityThreads[0].output,
-        terminatedAt: new Date(),
-        terminator: user
-      }
-  }
-}
-
-export async function createActivityThreadForUser(
-  transaction: string,
-  activityInstance: ActivityInstance,
-  assignee: User,
-  context: ResolverContext
-): Promise<ActivityThread> {
-  const { domain, user, tx } = context.state
-
-  const threadRepo = tx.getRepository(ActivityThread)
-  const now = new Date()
-
-  const result = await threadRepo.save({
-    domain,
-    assignee,
-    state: ActivityThreadStatus.Assigned,
-    activityInstance,
-    transaction,
-    output: activityInstance.output,
-    dueAt: activityInstance.dueAt,
-    assignedAt: now,
-    creator: user,
-    updater: user,
-    createdAt: now
-  })
-
-  await updateActivityInstanceState(activityInstance.id, { causedBy: [result] }, context)
-
-  return result
-}
-
-export async function createActivityThreadsForUsers(
-  transaction: string,
-  activityInstance: ActivityInstance,
-  assignees: User[],
-  context: ResolverContext
-): Promise<ActivityThread[]> {
-  const { domain, user, tx } = context.state
-
-  const threadRepo = tx.getRepository(ActivityThread)
-  const now = new Date()
-
-  const distinct = assignees.filter((assignee, idx) => {
-    return assignee && !assignees.slice(0, idx).find(x => x.id == assignee.id)
-  })
-
-  const result = await threadRepo.save(
-    distinct.map(assignee => {
-      return {
-        assignee,
-        state: ActivityThreadStatus.Assigned,
-        activityInstance,
-        domain,
-        transaction,
-        output: activityInstance.output,
-        creator: user,
-        updater: user,
-        dueAt: activityInstance.dueAt,
-        assignedAt: now
-      } as any
-    })
-  )
-
-  await updateActivityInstanceState(activityInstance.id, { causedBy: result }, context)
-
-  return result
-}
-
-export async function createActivityThreadsForAllRoleUsers(
-  transaction: string,
-  activityInstance: ActivityInstance,
-  context: ResolverContext
-): Promise<ActivityThread[]> {
-  const { tx } = context.state
-
-  // find how many users are having given role
-  const assigneeRole = (await tx.getRepository(Role).findOne({
-    where: { id: activityInstance.assigneeRoleId },
-    relations: ['users']
-  })) as Role
-  const assignees = (assigneeRole?.users || []).filter(user => user.userType == 'user')
-
-  if (assignees.length === 0) {
-    throw new Error("there's no users having given role")
-  }
-
-  // create activity-thread for all of users having given role
-  return await createActivityThreadsForUsers(transaction, activityInstance, assignees, context)
-}
-
-export async function getSystemUserFromMyDepartmentManager(context: ResolverContext): Promise<User> {
-  const { domain, user, tx } = context.state
-
-  const employee = await tx.getRepository(Employee).findOneBy({
-    domain: { id: domain.id },
-    user: { id: user.id }
-  })
-
-  if (!employee || !employee.departmentId) {
-    return
-  }
-
-  const department = await tx.getRepository(Department).findOne({
-    where: {
-      id: employee.departmentId
-    }
-  })
-
-  if (!department || !department.managerId) return
-
-  const manager = await tx.getRepository(Employee).findOne({
-    where: {
-      domain: { id: domain.id },
-      id: department.managerId
-    },
-    relations: ['user']
-  })
-
-  return manager?.user
-}
-
-export async function getSystemUserFromMySupervosor(context: ResolverContext): Promise<User> {
-  const { domain, user, tx } = context.state
-
-  const employee = await tx.getRepository(Employee).findOneBy({
-    domain: { id: domain.id },
-    user: { id: user.id }
-  })
-
-  if (!employee || !employee.supervisorId) {
-    return
-  }
-
-  const supervisor = await tx.getRepository(Employee).findOne({
-    where: {
-      id: employee.supervisorId
-    },
-    relations: ['user']
-  })
-
-  return supervisor?.user
-}
-
-export async function getSystemUserFromOrgMemberItem(
-  item: AssigneeItem | ApprovalLineItem,
-  context: ResolverContext
-): Promise<User> {
-  const { domain, user, tx } = context.state
-
-  const { type, approver, assignee, value } = item
-  const id = approver?.id || assignee?.id || value
-
-  if (type == OrgMemberTargetType.Employee) {
-    const employee = id && (await tx.getRepository(Employee).findOne({ where: { id }, relations: ['user'] }))
-
-    if (!employee || !employee.user) {
-      return
-    }
-    return employee.user
-  } else if (type == OrgMemberTargetType.Department) {
-    const department = id && (await tx.getRepository(Department).findOne({ where: { id }, relations: ['manager'] }))
-
-    if (!department || !department.manager) {
-      return
-    }
-    return await tx.getRepository(User).findOneBy({ id: department.manager.userId })
-  } else if (type == OrgMemberTargetType.Role) {
-    const role = id && (await tx.getRepository(Role).findOne({ where: { id }, relations: ['users'] }))
-
-    if (!role || !role.users || !role.users[0]) {
-      return
-    }
-
-    return await tx.getRepository(User).findOneBy({ id: role.users[0].id })
-  } else if (type == OrgMemberTargetType.Myself) {
-    return user
-  } else if (type == OrgMemberTargetType.MyDepartment) {
-    return await getSystemUserFromMyDepartmentManager(context)
-  } else if (type == OrgMemberTargetType.MySupervisor) {
-    return await getSystemUserFromMySupervosor(context)
-  }
-}
-
-export function fillActivitySearchKeys(searchKeys: ActivitySearchKeyItem[], input: { [key: string]: any }) {
-  if (!input || typeof input !== 'object') {
-    return
-  }
-
-  return searchKeys?.reduce((sum, key, index) => {
-    const value = input[key.inputKey]
-    if (value != null) {
-      sum[`key0${index + 1}`] = value instanceof Array ? value[0] : value
-    }
-    return sum
-  }, {})
-}

package/server/controllers/index.ts

@@ -1,2 +0,0 @@
-export * from './activity-installation/activity-installation-controller'
-export * from './activity-instance'

package/server/index.ts

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

package/server/routes.ts

@@ -1,73 +0,0 @@
-import { logger } from '@things-factory/env'
-import { Domain, getDataSource } from '@things-factory/shell'
-import { ScheduleRegisterRequest } from '@things-factory/scheduler-client'
-import { issue } from './controllers/activity-instance/issue'
-
-process.on('bootstrap-module-global-public-route' as any, (app, 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) => {})
-   */
-
-  /* When a callback occurs from the scheduler when a scheduled dataset is on schedule, data collection task for the dataset should be issued. */
-  globalPublicRouter.post('/callback-schedule-for-activity', async (context, next) => {
-    const { client } = context.request.body as ScheduleRegisterRequest
-
-    if (!client || typeof client !== 'object') {
-      throw new Error('client property should be a part of callback body.')
-    }
-
-    const { group: domainId, key: activityId } = client
-
-    if (!domainId || !activityId) {
-      throw new Error(`group(${domainId}) and key(${activityId}) properties should not be empty`)
-    }
-
-    if (!domainId || !activityId) {
-      throw new Error(`domainId(${domainId}) and activityId(${activityId}) properties should not be empty`)
-    }
-
-    await getDataSource().transaction(async tx => {
-      const domain = await tx.getRepository(Domain).findOneBy({ id: domainId })
-
-      if (!domain) {
-        throw new Error(`domain(${domainId}) not found`)
-      }
-
-      context.state = {
-        ...context.state,
-        domain,
-        tx
-      }
-
-      await issue(
-        {
-          activityId
-        },
-        context
-      )
-    })
-
-    context.status = 200
-  })
-})
-
-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)
-   */
-})