@things-factory/worklist 6.0.41 → 6.0.43

package/helps/worklist/worklist-concept.md

@@ -0,0 +1,69 @@
+# 워크리스트 개요
+
+## 유저태스크
+
+유저태스크(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 리스트는 작성자의 생각을 정리하는 데에도 도움이 됩니다. 작성자가 어떤 일을 해야 하는지 명확하게 파악하고, 일을 처리하는 과정에서 생각이 더해질 경우 리스트에 추가하고, 처리가 완료된 일은 리스트에서 제거하여 업무 처리 상황을 파악할 수 있습니다. 이를 통해 업무 처리의 투명성을 높이고, 업무 처리에 대한 관리와 추적이 용이해집니다.
+
+## DONE 리스트
+
+DONE 리스트는 이미 완료된 업무나 작업을 기록하는 리스트입니다. 즉, TODO 리스트에 작성한 일들을 실제로 처리하고 완료하면, 해당 업무나 작업을 DONE 리스트에 추가하여 기록합니다.
+
+DONE 리스트를 유지하는 것은 업무나 작업의 완료 상태를 파악하고, 추후에 해당 작업이나 업무를 참조해야 할 때 유용합니다. 또한, 완료된 작업들을 모아놓고 살펴보면, 자신이 수행한 일들에 대한 성취감과 자신감을 얻을 수 있습니다.
+
+또한, DONE 리스트를 통해 얻은 정보는 다음과 같은 용도로 활용할 수 있습니다.
+
+- 추후에 유사한 업무나 작업을 할 때, 이전에 수행한 일들을 참고하여 좀 더 효율적으로 처리할 수 있습니다.
+- 일정관리나 프로젝트 관리 시, 완료된 작업들의 기록을 통해 진척상황을 파악하고, 예상 완료일자를 조정하는 데 활용할 수 있습니다.
+- 회고를 할 때, DONE 리스트를 살펴보며 지난 시간 동안의 성취감과 더불어 개선할 점을 찾을 수 있습니다.
+
+(이 페이지는 ChatGPT로 작성되었습니다.)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "6.0.41",
+  "version": "6.0.43",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,14 +27,14 @@
   "dependencies": {
     "@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": "781f8ef2c026fc38c7485eaa6bd51367fbe7ec09"
+  "gitHead": "08a649f00a8f0f489142207cb34de4b28c2e5630"
 }

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'

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

@@ -22,6 +22,20 @@ export async function restart(
     )
   }
 
+  /* 
+    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
   }

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

@@ -18,7 +18,25 @@ export async function save(id: string, save: ActivityThreadSave, context: Resolv
     )
   }
 
+  /* 
+    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 ||
+    activityThread.state == ActivityThreadStatus.Delegated
+  ) {
+    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()
   }
 

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

@@ -22,6 +22,19 @@ export async function start(
     )
   }
 
+  /* 
+    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
   }