@things-factory/worklist 6.0.42 → 6.0.45

package/helps/worklist/activity-bank.md

@@ -0,0 +1,22 @@
+# 업무 뱅크
+
+## 개요
+
+워크리스트 시스템에서 미할당 업무들을 모아둔 곳인 업무뱅크는, 다양한 업무들을 포함하는 일종의 업무 목록 혹은 대기열(queue)입니다. 이 업무들은 일반적으로 프로젝트나 팀에서 진행해야 할 일들 중 미해결된 업무들로 구성됩니다. 업무뱅크에 포함된 업무들은 우선순위, 난이도, 기간 등 다양한 정보들을 가지고 있으며, 해당 업무를 담당하는 사용자가 할당되기 전까지는 "미할당 상태"로 존재합니다.
+
+업무뱅크에서 업무를 선택(pick)하면, 해당 업무를 수행할 수 있는 자격 역할을 가진 사용자가 그 업무를 자신의 TODO 리스트로 옮길 수 있습니다. 이렇게 옮겨진 업무는 해당 사용자의 개인 TODO 리스트에 추가되어, 이후 해당 사용자가 해당 업무를 수행하도록 할당됩니다.
+
+이러한 시스템을 통해, 업무뱅크를 통해 미할당된 업무들을 한 곳에서 모아서 효율적으로 관리할 수 있습니다. 또한, 업무를 수행하는 사용자들이 자신의 업무 선택을 할 수 있는 기능을 제공하여, 업무를 더욱 효과적으로 분배하고 업무 수행의 효율성을 높일 수 있습니다.
+
+## 업무 쇼핑
+
+아직 할당되지 않은 작업들의 리스트를 조회하고, 그 중에서 사용자가 스스로에게 해당 업무를 할당하여 수행할 수 있는 기능입니다.
+미할당 업무를 스스로에게 할당하는 것을 업무를 선택(PICK)한다고 하며, 이런 대상업무들이 업무뱅크에 리스트되어 있습니다.
+
+사용자가 업무뱅크에서 볼 수 있는 미할당 업무들은 사용자에게 할당되지는 않았지만, 해당 업무에 대해서 사용자가 수행할 수 있는 자격이 있는 업무들만 조회되게 됩니다.
+그러한 자격은 보통 시스템에서 부여된 역할(Role)에 의해서 결정됩니다.
+
+보통 업무를 정의하고 업무뱅크에 올릴 때(POST) 해당 업무를 수행할 수 있는 자격 역할(Role)을 지정하게 됩니다.
+따라서, 해당 역할(Role)을 가진 사용자들이 그 업무를 선택(PICK)할 수 있는 것입니다.
+
+사용자가 선택(PICK)한 업무는 나의 할일 리스트에 포함되게 되며, 업무뱅크 리스트에서 사라지게 됩니다.

package/helps/worklist/{activity-approval.md → activity-stats.md}

@@ -1,4 +1,4 @@
-# ActivityApproval
+# ActivityStats
 
 Paragraphs are separated by a blank line.
 

package/helps/worklist/draft-list.md

@@ -0,0 +1,15 @@
+# 작성중인 업무
+
+## 개요
+
+워크리스트 시스템에서 작성중인 업무는 일반적으로 "Draft" 상태로 분류됩니다. 이러한 업무는 아직 완료되지 않았거나, 작업이 일시 중단된 상태이며, 업무를 작성하고 있는 사용자가 해당 업무를 다시 가져와서 작업을 계속할 수 있도록 보관되어야 하는 상태입니다.
+
+따라서, 워크리스트 시스템에서는 해당 사용자가 작성중인 업무를 리스팅할 수 있는 기능을 제공합니다. 이를 통해, 작성중인 업무를 쉽게 찾을 수 있으며, 다시 해당 업무를 가져와서 작업을 이어나갈 수 있습니다. 일반적으로, 작성중인 업무를 리스팅하는 기능은 사용자의 개인적인 작업 대시보드에서 제공되며, 해당 사용자가 작성 중인 모든 업무들의 요약 정보를 한 눈에 볼 수 있도록 구성되어 있습니다.
+
+또한, 해당 기능은 작성중인 업무들의 상세 정보를 확인할 수 있는 링크를 제공하여, 사용자가 해당 업무의 내용을 다시 확인하거나 수정할 수 있도록 합니다. 이러한 기능을 통해, 작성중인 업무들을 보다 쉽게 관리하고, 업무 작성에 대한 효율성을 높일 수 있습니다.
+
+## 작동 방식
+
+"작성중인 업무"는 업무를 정의하고 할당하고자 하는 사용자가 업무를 기획하는 과정에서 초안작업(Draft) 중인 상태의 업무를 의미합니다.
+따라서, 이 상태의 업무는 아직 포스팅되기 전이며, 사용자가 그 과정에서 취소할 수도 있으며, 최종 완성하여 업무를 할당하거나 업무뱅크에 리스팅할 수도 있습니다.
+이렇게 작성완료되어 할당 또는 업무뱅크에 리스팅된 상태를 포스트(Posted) 상태라고 합니다.

package/helps/worklist/worklist-concept.md

@@ -0,0 +1,72 @@
+# 워크리스트 개요
+
+## 유저태스크
+
+유저태스크(User Task)는 BPMN(Business Process Model and Notation)에서 프로세스를 구성하는 액티비티(Activity) 중 하나로, 사용자가 직접 수행하는 타입의 태스크를 의미합니다.
+
+유저태스크는 프로세스에서 발생하는 업무나 작업 중에서 인간의 개입이 필요한 부분을 나타내며, 일반적으로 사용자에게 할당되어 수행됩니다. 예를 들어, 고객 정보를 입력받는 폼을 작성하거나, 결재 문서를 검토하고 승인하는 과정 등이 유저태스크에 해당됩니다.
+
+유저태스크는 다른 액티비티와 마찬가지로 입력(Input), 출력(Output), 수행 조건(Condition) 등을 가지며, 이를 바탕으로 프로세스의 실행 흐름을 결정합니다. 또한, 유저태스크는 프로세스 진행 상황을 추적하고 모니터링할 수 있도록 사용자 인터페이스를 제공하는 것이 일반적입니다.
+
+유저태스크의 수행은 사용자가 직접 수행하는 것이기 때문에, 수행 시간이 상대적으로 불확실하고 변동이 큰 경우가 많습니다. 따라서, 프로세스의 설계나 구현 시에는 이러한 부분을 고려하여 적절한 조치를 취해야 합니다. 예를 들어, 대기 시간을 최소화하거나, 자동화된 예외 처리를 구현하는 등의 방법이 있습니다.
+
+## 워크리스트
+
+워크리스트(Worklist)는 BPM(Business Process Management) 시스템에서 유저태스크를 관리하는 데 사용되는 모듈입니다. 워크리스트는 사용자가 자신에게 할당된 유저태스크 목록을 제공하며, 이를 기반으로 작업을 수행하고, 결과를 제출할 수 있도록 도와줍니다.
+
+구체적인 기능으로는 다음과 같은 것들이 있습니다.
+
+- 할당된 작업 목록 확인: 워크리스트는 사용자에게 할당된 모든 유저태스크 목록을 제공합니다. 이를 통해 사용자는 자신에게 할당된 작업의 현황을 한 눈에 파악할 수 있습니다.
+- 작업 수행: 사용자는 워크리스트에서 제공하는 인터페이스를 통해 유저태스크를 수행할 수 있습니다. 예를 들어, 결재 문서를 검토하고 승인 또는 거절하는 등의 작업을 수행할 수 있습니다.
+- 작업 상태 추적: 워크리스트는 각 유저태스크의 수행 상태를 추적하여, 현재 작업이 어느 단계에 있는지를 알려줍니다. 이를 통해 사용자는 작업이 얼마나 진행되었는지를 파악할 수 있습니다.
+- 히스토리 조회: 워크리스트는 사용자가 수행한 작업의 히스토리를 제공합니다. 이를 통해 사용자는 자신이 어떤 작업을 수행했는지, 언제 수행했는지 등을 파악할 수 있습니다.
+- 예외 처리: 워크리스트는 예외 상황 발생 시에도 적절한 조치를 취할 수 있도록 도와줍니다. 예를 들어, 다른 사용자에게 작업을 할당하거나, 자동으로 작업을 다시 할당하는 등의 기능을 제공합니다.
+
+이와 같은 기능을 통해 워크리스트는 사용자가 유저태스크를 효율적으로 수행할 수 있도록 도와주며, 프로세스의 실행을 원활하게 진행할 수 있도록 지원합니다.
+
+## 유저태스크 상태전이
+
+워크리스트에서 관리하는 유저태스크의 상태는 보통 다음과 같이 정의됩니다.
+
+- 대기(Waiting): 유저태스크가 생성되었지만, 아직 수행 가능한 사용자가 할당되지 않은 상태입니다.
+- 할당(Assigned): 유저태스크가 수행 가능한 사용자에게 할당된 상태입니다.
+- 진행중(In progress): 유저태스크가 수행 중인 상태입니다.
+- 보류(Hold): 유저태스크의 수행이 일시 중단된 상태입니다.
+- 완료(Completed): 유저태스크의 수행이 완료된 상태입니다.
+
+각 상태 전이를 일으키는 이벤트는 다음과 같이 정의됩니다.
+
+- 할당: 대기 상태의 유저태스크가 수행 가능한 사용자에게 할당됩니다.
+- 수락: 할당 상태의 유저태스크가 사용자에게 수락되어 진행 중인 상태가 됩니다.
+- 보류: 진행 중인 유저태스크가 보류 상태가 됩니다.
+- 재개: 보류 상태의 유저태스크가 다시 진행 중인 상태가 됩니다.
+- 완료: 진행 중인 유저태스크가 완료 상태가 됩니다.
+
+## TODO 리스트 (나의 할일 리스트)
+
+TODO 리스트는 업무 처리에서 아직 해야 할 일들을 기록하고 추적하는 방법 중 하나입니다. 예를 들어, 업무 처리 중에 다음과 같은 상황이 생길 수 있습니다.
+
+- 중요한 일을 먼저 처리해야 할 때
+- 기한이 다가오는 일정을 놓치지 않기 위해 일정 조율이 필요할 때
+- 다른 사람과 공유해야 할 정보를 적어두고 추적해야 할 때
+
+이런 경우, TODO 리스트를 작성하고 업무 처리 상황에 따라 업무를 우선순위에 따라 정렬하거나 필요한 정보를 추가로 작성하고 삭제하는 등의 작업을 수행할 수 있습니다. 이를 통해 업무 처리를 보다 체계적으로 관리할 수 있으며, 더욱 효율적으로 일을 처리할 수 있습니다.
+
+또한, TODO 리스트는 작성자의 생각을 정리하는 데에도 도움이 됩니다. 작성자가 어떤 일을 해야 하는지 명확하게 파악하고, 일을 처리하는 과정에서 생각이 더해질 경우 리스트에 추가하고, 처리가 완료된 일은 리스트에서 제거하여 업무 처리 상황을 파악할 수 있습니다. 이를 통해 업무 처리의 투명성을 높이고, 업무 처리에 대한 관리와 추적이 용이해집니다.
+
+## 승인 대기 리스트
+
+승인 대기 리스트는 업무 진행자가 자신이 수행한 업무에 대한 검토나 지속적인 추진을 위해서 관리자의 승인을 요청한 것들 중에서 내가 승인 또는 반려 처리해야하는 리스트를 보여줍니다.
+
+사용자는 승인 대기 리스트에서 처리하고자 하는 업무를 선택하고 승인 또는 반려 처리를 할 수 있습니다.
+이 과정에서 승인 또는 반려의 사유 등 판단의 근거를 코멘트로 남기도록 하고 있습니다.
+
+사용자가 승인 또는 반려한 업무 이력은 '내가 수행한 승인리스트'에서 조회할 수 있습니다.
+
+## 내가 수행한 승인리스트
+
+내가 수행한 승인리스트는 이미 처리된 승인 업무를 기록하는 리스트입니다.
+
+내가 수행한 승인리스트를 유지하는 것은 업무나 작업의 처리상태를 파악하고, 추후에 해당 작업이나 업무를 참조해야 할 때 유용합니다.
+
+(이 페이지는 ChatGPT로 작성되었습니다.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "6.0.42",
+  "version": "6.0.45",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -25,16 +25,17 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
+    "@operato/event-view": "^1.0.0",
     "@operato/graphql": "^1.0.0",
     "@operato/grist-editor": "^1.0.0",
-    "@things-factory/attachment-base": "^6.0.34",
-    "@things-factory/auth-base": "^6.0.34",
-    "@things-factory/board-service": "^6.0.34",
-    "@things-factory/context-ui": "^6.0.34",
-    "@things-factory/organization": "^6.0.40",
-    "@things-factory/scheduler-client": "^6.0.35",
-    "@things-factory/shell": "^6.0.34",
+    "@things-factory/attachment-base": "^6.0.43",
+    "@things-factory/auth-base": "^6.0.43",
+    "@things-factory/board-service": "^6.0.43",
+    "@things-factory/context-ui": "^6.0.43",
+    "@things-factory/organization": "^6.0.43",
+    "@things-factory/scheduler-client": "^6.0.43",
+    "@things-factory/shell": "^6.0.43",
     "moment-timezone": "^0.5.40"
   },
-  "gitHead": "01c352d388f5c899aa3f662565e8dbb273c51104"
+  "gitHead": "7ed9a41bd28093df9b43126ee38c0cdd0522afda"
 }

package/server/controllers/activity-approval/_abort.ts

@@ -0,0 +1,20 @@
+import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
+
+export async function _abort(
+  { activityApproval, comment }: { activityApproval: ActivityApproval; comment: string },
+  context: ResolverContext
+): Promise<ActivityApproval> {
+  const { domain, user, tx } = context.state
+
+  var result = await tx.getRepository(ActivityApproval).save({
+    ...activityApproval,
+    judgment: ActivityApprovalJudgment.Aborted,
+    comment,
+    transaction: 'abort',
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  })
+
+  return result
+}

package/server/controllers/activity-approval/abort.ts

@@ -0,0 +1,44 @@
+import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
+import { updateActivityInstanceState } from '../common'
+import { _abort } from './_abort'
+
+export async function abort(
+  { id, comment }: { id: string; comment: string },
+  context: ResolverContext
+): Promise<ActivityApproval> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ActivityApproval)
+
+  var activityApproval = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: ['activityThread']
+  })
+
+  if (!activityApproval) {
+    throw new Error(
+      context.t('error.activity-approval not found', {
+        activityApproval: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisite of Abortion
+    - Previous judgement should be 'pending'
+  */
+  if (activityApproval.judgment !== ActivityApprovalJudgment.Pending) {
+    throw new Error(
+      context.t(`error.activity-approval is already terminated`, {
+        activityInstance: id,
+        actual: activityApproval.judgment
+      })
+    )
+  }
+
+  var result = await _abort({ activityApproval, comment }, context)
+
+  await updateActivityInstanceState(activityApproval.activityThread.activityInstanceId, context)
+
+  return result
+}

package/server/controllers/activity-approval/approve.ts

@@ -24,6 +24,19 @@ export async function approve(
     )
   }
 
+  /* 
+    Prerequisite of Approval
+    - Previous judgement should be 'pending'
+  */
+  if (activityApproval.judgment !== ActivityApprovalJudgment.Pending) {
+    throw new Error(
+      context.t(`error.activity-approval is already terminated`, {
+        activityInstance: id,
+        actual: activityApproval.judgment
+      })
+    )
+  }
+
   const activityThread = await tx.getRepository(ActivityThread).findOne({
     where: { domain: { id: domain.id }, id: activityApproval.activityThreadId },
     relations: ['activityInstance']

package/server/controllers/activity-approval/delegate.ts

@@ -22,6 +22,19 @@ export async function delegate(
     )
   }
 
+  /* 
+    Prerequisite of Delegation
+    - Previous judgement should be 'pending'
+  */
+  if (activityApproval.judgment !== ActivityApprovalJudgment.Pending) {
+    throw new Error(
+      context.t(`error.activity-approval is already terminated`, {
+        activityInstance: id,
+        actual: activityApproval.judgment
+      })
+    )
+  }
+
   /* TODO user validation .. */
   const approver = await tx.getRepository(User).findOneBy({ id: to.id })
 

package/server/controllers/activity-approval/reject.ts

@@ -23,6 +23,19 @@ export async function reject(
     )
   }
 
+  /* 
+    Prerequisite of Rejection
+    - Previous judgement should be 'pending'
+  */
+  if (activityApproval.judgment !== ActivityApprovalJudgment.Pending) {
+    throw new Error(
+      context.t(`error.activity-approval is already terminated`, {
+        activityInstance: id,
+        actual: activityApproval.judgment
+      })
+    )
+  }
+
   var result = await repository.save({
     ...activityApproval,
     judgment: ActivityApprovalJudgment.Rejected,

package/server/controllers/activity-instance/abort.ts

@@ -1,6 +1,9 @@
-import { ActivityInstance } from '../../service/activity-instance/activity-instance'
+import { ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
+import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
 import { evalActivityInstanceState } from '../common'
 
+import { _abort as abortActivityThread } from '../activity-thread/_abort'
+
 export async function abort(
   { id, reason }: { id: string; reason: string },
   context: ResolverContext
@@ -11,7 +14,17 @@ export async function abort(
 
   var activityInstance = await repository.findOne({
     where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activity', 'assigneeRole', 'supervisoryRole', 'updater', 'creator', 'starter', 'terminator']
+    relations: [
+      'domain',
+      'activity',
+      'activityThreads',
+      'assigneeRole',
+      'supervisoryRole',
+      'updater',
+      'creator',
+      'starter',
+      'terminator'
+    ]
   })
 
   if (!activityInstance) {
@@ -22,6 +35,37 @@ export async function abort(
     )
   }
 
+  /* 
+    Prerequisites for a Task to Be Aborted.
+    - The previous state of the task must not be End or Aborted.
+  */
+  if (
+    activityInstance.state == ActivityInstanceStatus.Aborted ||
+    activityInstance.state == ActivityInstanceStatus.Ended
+  ) {
+    throw new Error(
+      context.t(`error.activity-instance is already terminated`, {
+        id,
+        state: activityInstance.state
+      })
+    )
+  }
+
+  /* 
+    Actions to be processed when a task is aborted
+    - All related activity threads must be aborted.
+  */
+
+  const TERMINATED = [ActivityThreadStatus.Aborted, ActivityThreadStatus.Delegated, ActivityThreadStatus.Ended]
+
+  for (let activityThread of activityInstance.activityThreads) {
+    if (TERMINATED.includes(activityThread.state)) {
+      continue
+    }
+
+    await abortActivityThread({ activityThread, reason }, context)
+  }
+
   return await repository.save({
     ...activityInstance,
     reason,

package/server/controllers/activity-instance/assign.ts

@@ -2,7 +2,7 @@ import { In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 
-import { ActivityInstance } from '../../service/activity-instance/activity-instance'
+import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
 import { createActivityThreadsForUsers } from '../common'
 
 export async function assign(
@@ -26,6 +26,22 @@ export async function assign(
     )
   }
 
+  /* 
+    Prerequisites for a Task to Be Assigned.
+    - The previous state of the task must not be Assigned.
+  */
+  if (
+    activityInstance.state !== ActivityInstanceStatus.Posted &&
+    activityInstance.state !== ActivityInstanceStatus.PendingAssignment
+  ) {
+    throw new Error(
+      context.t(`error.activity-instance should not be assigned`, {
+        id,
+        actual: activityInstance.state
+      })
+    )
+  }
+
   if (dueAt) {
     activityInstance.dueAt = dueAt
   }

package/server/controllers/activity-instance/end.ts

@@ -1,4 +1,5 @@
-import { ActivityInstance } from '../../service/activity-instance/activity-instance'
+import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
+import { ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
 import { evalActivityInstanceState } from '../common'
 
 export async function end(
@@ -10,7 +11,17 @@ export async function end(
 
   var activityInstance = await repository.findOne({
     where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activity', 'assigneeRole', 'supervisoryRole', 'updater', 'creator', 'starter', 'terminator']
+    relations: [
+      'domain',
+      'activity',
+      'activityThreads',
+      'assigneeRole',
+      'supervisoryRole',
+      'updater',
+      'creator',
+      'starter',
+      'terminator'
+    ]
   })
 
   if (!activityInstance) {
@@ -21,6 +32,38 @@ export async function end(
     )
   }
 
+  /* 
+    Prerequisites for a Task to Be End.
+    - The previous state of the task must not be End or Aborted.
+    - There should be no unfinished activity threads.
+  */
+  if (
+    activityInstance.state == ActivityInstanceStatus.Aborted ||
+    activityInstance.state == ActivityInstanceStatus.Ended
+  ) {
+    throw new Error(
+      context.t(`error.activity-instance is already terminated`, {
+        id,
+        state: activityInstance.state
+      })
+    )
+  }
+
+  const TERMINATED = [ActivityThreadStatus.Aborted, ActivityThreadStatus.Delegated, ActivityThreadStatus.Ended]
+
+  for (let activityThread of activityInstance.activityThreads) {
+    if (TERMINATED.includes(activityThread.state)) {
+      continue
+    }
+
+    throw new Error(
+      context.t(`error.all activity threads should be terminated`, {
+        activityThread: activityThread.id,
+        state: activityInstance.state
+      })
+    )
+  }
+
   if (!activityInstance.startedAt) {
     activityInstance.startedAt = new Date()
   }

package/server/controllers/activity-instance/index.ts

@@ -2,9 +2,5 @@ export * from './draft'
 export * from './post'
 export * from './pick'
 export * from './assign'
-export * from './delegate'
 export * from './abort'
 export * from './end'
-export * from './start'
-export * from './terminate'
-export * from './adjust'

package/server/controllers/activity-instance/pick.ts

@@ -1,4 +1,4 @@
-import { ActivityInstance } from '../../service/activity-instance/activity-instance'
+import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
 import { ActivityThread } from '../../service/activity-thread/activity-thread'
 import { createActivityThreadsForUsers } from '../common'
 
@@ -19,6 +19,22 @@ export async function pick(id: string, context: ResolverContext): Promise<Activi
     )
   }
 
+  /* 
+    Prerequisites for a Task to Be Picked.
+    - The previous state of the task must not be Assigned.
+  */
+  if (
+    activityInstance.state !== ActivityInstanceStatus.Posted &&
+    activityInstance.state !== ActivityInstanceStatus.PendingAssignment
+  ) {
+    throw new Error(
+      context.t(`error.activity-instance should not be assigned`, {
+        id,
+        actual: activityInstance.state
+      })
+    )
+  }
+
   const picked = await repository.save({
     ...activityInstance,
     transaction: 'pick',

package/server/controllers/activity-instance/post.ts

@@ -49,6 +49,19 @@ export async function post(
       })
     : null
 
+  /* 
+    Prerequisites for a Task to Be Posted.
+    - The previous state of the task should be Draft.
+  */
+  if (origin && origin.state !== ActivityInstanceStatus.Draft) {
+    throw new Error(
+      context.t(`error.activity-instance is already posted`, {
+        id: id,
+        state: origin.state
+      })
+    )
+  }
+
   if (!origin && activityId) {
     var repository = tx.getRepository(Activity)
     var activity = {} as Activity

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

@@ -0,0 +1,43 @@
+import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
+import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
+import { _abort as abortActivityApproval } from '../activity-approval/_abort'
+
+export async function _abort(
+  { activityThread, reason }: { activityThread: ActivityThread; reason: string },
+  context: ResolverContext
+): Promise<ActivityThread> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ActivityThread)
+
+  let activityApprovals = await tx.getRepository(ActivityApproval).find({
+    where: {
+      activityThread: { id: activityThread.id },
+      judgment: ActivityApprovalJudgment.Pending
+    }
+  })
+
+  /* 
+    Actions to be processed when a activity thread is aborted
+    - All related activity approvals must be aborted.
+  */
+  for (let activityApproval of activityApprovals) {
+    await abortActivityApproval(
+      {
+        activityApproval,
+        comment: reason
+      },
+      context
+    )
+  }
+
+  return await repository.save({
+    ...activityThread,
+    reason,
+    state: ActivityThreadStatus.Aborted,
+    transaction: 'abort',
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  })
+}

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

@@ -1,5 +1,6 @@
 import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
 import { updateActivityInstanceState } from '../common'
+import { _abort } from './_abort'
 
 export async function abort(
   { id, reason }: { id: string; reason: string },
@@ -22,21 +23,30 @@ export async function abort(
     )
   }
 
+  /* 
+    Prerequisites for a activity thread to Be Aborted.
+    - The previous state of the activity thread must not be End or Aborted.
+  */
+  if (
+    activityThread.state == ActivityThreadStatus.Aborted ||
+    activityThread.state == ActivityThreadStatus.Ended ||
+    activityThread.state == ActivityThreadStatus.Delegated
+  ) {
+    throw new Error(
+      context.t(`error.activity-thread is already terminated`, {
+        id,
+        state: activityThread.state
+      })
+    )
+  }
+
   if (!activityThread.startedAt) {
     activityThread.startedAt = new Date()
   }
 
-  activityThread = await repository.save({
-    ...activityThread,
-    reason,
-    state: ActivityThreadStatus.Aborted,
-    transaction: 'abort',
-    updater: user,
-    terminatedAt: new Date(),
-    terminator: user
-  })
+  const result = await _abort({ activityThread, reason }, context)
 
   await updateActivityInstanceState(activityThread.activityInstanceId, context)
 
-  return activityThread
+  return result
 }

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

@@ -31,6 +31,19 @@ export async function delegate(
     )
   }
 
+  /* 
+    Prerequisites for a activity thread to Be Delegated.
+    - The previous state of the activity thread should be assigned or started.
+  */
+  if (activityThread.state !== ActivityThreadStatus.Assigned && activityThread.state !== ActivityThreadStatus.Started) {
+    throw new Error(
+      context.t(`error.activity-thread is already terminated`, {
+        id,
+        actual: activityThread.state
+      })
+    )
+  }
+
   if (dueAt) {
     activityThread.dueAt = dueAt
   }

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

@@ -21,6 +21,23 @@ export async function end(
     )
   }
 
+  /* 
+    Prerequisites for a activity thread to Be End.
+    - The previous state of the activity thread must not be End or End.
+  */
+  if (
+    activityThread.state == ActivityThreadStatus.Aborted ||
+    activityThread.state == ActivityThreadStatus.Ended ||
+    activityThread.state == ActivityThreadStatus.Delegated
+  ) {
+    throw new Error(
+      context.t(`error.activity-thread is already terminated`, {
+        id,
+        actual: activityThread.state
+      })
+    )
+  }
+
   if (!activityThread.startedAt) {
     activityThread.startedAt = new Date()
   }

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

@@ -5,5 +5,3 @@ export * from './submit'
 export * from './save'
 export * from './start'
 export * from './restart'
-export * from './terminate'
-export * from './adjust'