@things-factory/worklist 6.0.45 → 6.0.46

package/helps/worklist/activity.md

@@ -0,0 +1,91 @@
+# 업무정의(Activity)
+
+Activity는 "업무정의" 라고 이해할 수 있다.
+
+워크리스트 시스템에서는 업무의 인스턴스를 생성하고 수행, 검토, 결재 승인, 완료 까지의 업무인스턴스의 라이프사이클을 관리하며, 사용자와 인터렉션을 통해서 업무 수행의 효율을 높이는 시스템이다.
+이 업무 인스턴스의 모델이 되는 것을 "Activity"라고 한다.
+
+## 워크리스트 내부 엔티티 구조
+
+- 업무정의 : Activity
+- 업무인스턴스 : Activity Instance
+- 업무쓰레드 : Activity Thread - 하나의 업무인스턴스는 여러 피할당자에 의해서 수행될 수 있는데, 각각의 피할당자의 업무 진행과정을 관리하는 엔티티이다.
+- 승인 이력 : Activity Approval - 업무 쓰레드에 대한 각각의 승인과정을 관리하는 엔티티이다.
+
+## 업무정의의 속성
+
+- 이름 : 업무정의의 이름이며, 해당 업무정의로 생성된 업무인스턴스들의 디폴트 이름으로 제시된다.
+- 설명 : 업무정의에 대한 설명이며, 해당 업무정의로 생성된 업무인스턴스들의 디폴트 설명으로 제시된다.
+- 상태
+  - 초안작업중 : 업무정의를 작성중이며 배포되기 전이다. 업무인스턴스를 생성할 수 없는 상태이다.
+  - 배포됨 : 업무정의가 완료되어 배포된 상태이다.
+  - 폐기 : 업무정의가 더 이상 사용되지 않고 폐기되었다.
+- 업무타입
+  - BPMN 2.0 명세에 의한 태스크 타입이다.
+  - 사용자가 수행하는 업무는 'User' 태스크 타입을 지정한다.
+- 시작 유형
+  - [새업무 시작](./starter-list.md)의 시작업무 유형을 참고한다.
+- 다중인스턴스 유형
+  - 하나의 업무인스턴스의 피할당자를 한명만 할 것인지, 여러명을 할 것인지를 지정하며, 여러명인 경우 동시에 수행할지, 순차적으로 수행할지를 지정한다.
+  - parallel : 여러 할당자가 동시에 하나의 업무인스턴스를 수행하는 경우
+  - sequential : 여러 할당자가 순처적으로 하나의 업무인스턴스를 수행하는 경우
+  - 설정하지 않으면, 단일 피할당자에 의해서만 수행됨을 의미한다.
+- 검색 키
+  - 업무인스턴스 이력에서 데이터를 기반으로 검색할 수 있도록, input 데이타들 중에서 5개까지 검색키로 지정할 수 있다.
+  - 해당 업무정의의 업무인스턴스 중에서 내가 수행한 업무들은 '업무수행이력' 메뉴에서 검색해볼 수 있는데, '업무수행이력'의 하위메뉴 중에서 업무정의의 이름과 동일한 메뉴에서 검색해볼 수 있다.
+  - 검색 키로 지정된 input 데이타는 이 메뉴에서 검색키로 활용된다.
+- 우선순위
+  - 업무인스턴스의 디폴트 우선순위로 제시된다.
+- 스케쥴
+  - 업무정의는 스케쥴에 의해서 인스턴스가 자동 생성될 수 있다. 여기서는 자동생성을 위한 스케쥴을 설정할 수 있다.
+- 타임존
+  - 스케쥴 설정의 타임존을 설정한다.
+- 미리보기
+  - 업무정의를 상징하는 이미지를 설정할 수 있다. 특히 모바일 환경에서 카드형식의 리스트에서 각 업무들을 식별하는데 효과적이다.
+- 발급자 역할
+  - 사용자의 [시작가능한 업무]('./start-list.md')에 리스트될 수 있기 위해서는 발급자 역할을 가진 사용자 이어야 한다.
+  - 이 업무정의로 부터 업무 인스턴스를 생성할 수 있는 역할군을 지정한다.
+- 피할당 역할
+  - 이 업무정의의 인스턴스의 피할당자가 될 수 있는 역할 군을 지정한다.
+  - [업무뱅크](./activity-bank.md)에 게시하는 경우, 해당 역할을 가진 사람만이 PICK할 수 있다.
+- 관리자 역할
+  - 이 업무정의의 관리자 역할 군을 지정한다.
+  - 관리자는 이 업무정의의 모든 인스턴스의 현황과 이력을 조회할 수 있다.
+- 피할당자들(assignees)
+  - 업무인스턴스의 디폴트 피할당자들을 조직 체계 내에서 지정할 수 있다.
+  - 이 피할당자들은 이 업무정의의 인스턴스가 issue될 때 자동으로 피할당된다.
+- 결재선(approval line)
+  - 피할당자에 의해서 업무쓰레드가 수행되어 제출(submit)되면, 해당 결재선을 타고 승인의 과정을 거치게 된다.
+- 화면타입
+  - 업무생성 및 수행과정에 시스템에 의해서 작성자에게 보여지게될 작업 화면의 유형
+  - Generated : 업무정의 모델에 의해서 동적으로 자동 생성된다.
+  - Template :
+  - Board : 화면 소스에 설정한 보드가 보여진다.
+  - CustomElement : 데이타 인터렉션 규약을 만족하는 커스텀 엘리먼트가 보여진다. 해당 커스텀엘리먼트는 in/out data를 입력으로 받고, in/out이 수정될 때 이벤트를 발생시키는 규약을 만족하여야 한다.
+  - Page : 브라우저의 페이지 라우팅을 지정할 수 있다.
+  - External URL : 외부 URL을 지정할 수 있다.
+- 화면소스
+  - 화면타입에 해당하는 상세 설정을 한다.
+- 뷰타입
+  - 업무수행과정 또는 이력을 조회할 때 보여지게될 작업 화면의 유형
+  - Generated : 업무정의 모델에 의해서 동적으로 자동 생성된다.
+  - Template :
+  - Board : 화면 소스에 설정한 보드가 보여진다.
+  - CustomElement : 데이타 인터렉션 규약을 만족하는 커스텀 엘리먼트가 보여진다. 해당 커스텀엘리먼트는 in/out data를 입력으로 받고, in/out이 수정될 때 이벤트를 발생시키는 규약을 만족하여야 한다.
+  - Page : 브라우저의 페이지 라우팅을 지정할 수 있다.
+  - External URL : 외부 URL을 지정할 수 있다.
+- 뷰소스
+  - 뷰타입에 해당하는 상세 설정을 한다.
+- 리포트타입
+  - 업무정의와 관련된 리포트를 제공할 때 보여지게될 작업 화면의 유형
+  - Generated : 업무정의 모델에 의해서 동적으로 자동 생성된다.
+  - Template :
+  - Board : 화면 소스에 설정한 보드가 보여진다.
+  - CustomElement : 데이타 인터렉션 규약을 만족하는 커스텀 엘리먼트가 보여진다. 해당 커스텀엘리먼트는 in/out data를 입력으로 받고, in/out이 수정될 때 이벤트를 발생시키는 규약을 만족하여야 한다.
+  - Page : 브라우저의 페이지 라우팅을 지정할 수 있다.
+  - External URL : 외부 URL을 지정할 수 있다.
+- 리포트소스
+  - 리포트타입에 해당하는 상세 설정을 한다.
+- 표준시간(ST)
+  - 이 업무정의로 만들어지는 업무인스턴스의 표준 수행시간을 의미한다.
+  - 이 업무정의로 만들어지는 업무인스턴스의 만기시간을 계산하기위해 설정된다.

package/helps/worklist/draft-list.md

@@ -8,8 +8,12 @@
 
 또한, 해당 기능은 작성중인 업무들의 상세 정보를 확인할 수 있는 링크를 제공하여, 사용자가 해당 업무의 내용을 다시 확인하거나 수정할 수 있도록 합니다. 이러한 기능을 통해, 작성중인 업무들을 보다 쉽게 관리하고, 업무 작성에 대한 효율성을 높일 수 있습니다.
 
+### 작성중인 업무의 2가지 유형
+
+[새업무 시작하기](./starter-list.md)에서 작성중인 업무의 2가지 유형에 대해서 참고하시기 바랍니다.
+
 ## 작동 방식
 
 "작성중인 업무"는 업무를 정의하고 할당하고자 하는 사용자가 업무를 기획하는 과정에서 초안작업(Draft) 중인 상태의 업무를 의미합니다.
 따라서, 이 상태의 업무는 아직 포스팅되기 전이며, 사용자가 그 과정에서 취소할 수도 있으며, 최종 완성하여 업무를 할당하거나 업무뱅크에 리스팅할 수도 있습니다.
-이렇게 작성완료되어 할당 또는 업무뱅크에 리스팅된 상태를 포스트(Posted) 상태라고 합니다.
+이렇게 작성 완료되어 할당 또는 업무뱅크에 리스팅된 상태를 이슈된(Issued) 상태라고 합니다.

package/helps/worklist/starter-list.md

@@ -0,0 +1,34 @@
+# 새업무 시작하기
+
+## 개요
+
+### 시작 가능 업무 (startable)
+
+업무정의리스트에 정의된 업무들 중에서, 사용자가 임의로 시작할 수 있는 업무를 '시작 가능(startable)' 업무라고 합니다.
+
+업무를 선택하여 제목과 설명을 입력하고 '초안 저장'을 클릭하면, 새로운 업무가 생성되고 상세한 내용을 작성할 수 있도록 해당 업무화면으로 열립니다.
+그 업무는 [작성중인 업무](./draft-list.md)에 리스트되며, 언제든지 다시 열어서 편집할 수 있습니다.
+
+### 시작 유형 (starting type)
+
+시작 가능 업무는 두가지 유형으로 나뉩니다.
+
+- 업무 할당 (issue) 유형
+
+'업무 할당' 유형의 업무는 누군가(assignees)에게 업무를 할당하기 위해서 시작하는 업무입니다.
+업무를 할당하기 위해서는 업무에 대한 설명과 주요 입력값을 업무를 수행할 피할당자(assignees)에게 제공해주어야 합니다.
+이렇게 업무할당을 위해서 업무에 대한 설명과 입력값을 작성하는 작업을 위한 시작 유형이 '업무 할당(issue)' 입니다.
+
+이 업무 작성이 완료되어 '업무 할당(issue)'을 하게되면, 피할당자의 '나의 할일'리스트에 해당업무가 할당되게 됩니다.
+
+업무 피할당자와 결재선은 업무정의리스트에 기본적으로 정의되어있으며, 업무 할당 과정에서 수정할 수 있습니다.
+
+- 업무 게시 (post) 유형
+
+'업무 게시(post)' 유형의 업무는 시작하는 사람이 해당업무를 시작하고 마무리해서 필요시 관리자의 결재를 위해 제출까지 하는 유형입니다.
+이 유형의 업무는 업무 할당과정이 없이 업무를 시작하는 사람이 바로 피할당자가 되며, 게시와 동시에 업무는 마무리되거나 결재를 위해 제출되게 됩니다.
+
+이 업무 작성이 완료되어 '업무 게시(post)'를 하게되면, 결재과정이 없다면, 업무는 바로 완료되어 작성자의 업무 수행 이력에서 찾아볼 수 있게 됩니다.
+결재 과정이 있다면, 작성자의 '나의 할일' 리스트서에 결재가 완료될 때까지 대기하게 됩니다.
+
+업무 피할당자와 결재선은 업무정의리스트에 기본적으로 정의되어있으며, 업무 할당 과정에서 수정할 수 있습니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "6.0.45",
+  "version": "6.0.46",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -37,5 +37,5 @@
     "@things-factory/shell": "^6.0.43",
     "moment-timezone": "^0.5.40"
   },
-  "gitHead": "7ed9a41bd28093df9b43126ee38c0cdd0522afda"
+  "gitHead": "0fc79b215a4dabc07d2a73432e09f57252d55d83"
 }

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

@@ -31,7 +31,7 @@ export async function assign(
     - The previous state of the task must not be Assigned.
   */
   if (
-    activityInstance.state !== ActivityInstanceStatus.Posted &&
+    activityInstance.state !== ActivityInstanceStatus.Issued &&
     activityInstance.state !== ActivityInstanceStatus.PendingAssignment
   ) {
     throw new Error(

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

@@ -1,18 +1,47 @@
 import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
-import { NewActivityInstance } from '../../service/activity-instance/activity-instance-type'
+import { ActivityInstanceDraft } from '../../service/activity-instance/activity-instance-type'
 import { Activity } from '../../service/activity/activity'
 import { fillActivitySearchKeys } from '../common'
 
 export async function draft(
-  activityInstance: NewActivityInstance,
+  activityInstance: ActivityInstanceDraft,
   context: ResolverContext
 ): Promise<ActivityInstance> {
   const { domain, user, tx } = context.state
-  const { activityId, input, dueAt } = activityInstance
+  const { id, activityId, input, dueAt } = activityInstance
 
   var repository = tx.getRepository(Activity)
   var activity = {} as Activity
 
+  if (id) {
+    var previousActivityInstance = await tx.getRepository(ActivityInstance).findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['activity']
+    })
+
+    if (!previousActivityInstance) {
+      throw new Error(
+        context.t('error.activityInstance not found', {
+          activityInstance: id
+        })
+      )
+    }
+
+    if (previousActivityInstance.state !== ActivityInstanceStatus.Draft) {
+      throw new Error(
+        context.t('error.activityInstance state should be draft', {
+          activityInstance: id,
+          state: previousActivityInstance.state
+        })
+      )
+    }
+
+    activity = previousActivityInstance.activity
+  } else {
+    activityInstance.adhocType = 'standard'
+    activityInstance.refBy = activityId
+  }
+
   if (activityId) {
     activity = await repository.findOne({
       where: { domain: { id: domain.id }, id: activityId },
@@ -28,8 +57,6 @@ export async function draft(
     }
   }
 
-  activityInstance.adhocType = 'standard'
-  activityInstance.refBy = activityId
   if (!activityInstance.assignees) {
     activityInstance.assignees = activity.assignees
   }
@@ -48,7 +75,6 @@ export async function draft(
         value: assignee.value
       }
     })
-  } else {
   }
 
   if (activityInstance.approvalLine) {
@@ -63,6 +89,7 @@ export async function draft(
   const activitySearchKeys = fillActivitySearchKeys(activity?.searchKeys, input)
 
   return await tx.getRepository(ActivityInstance).save({
+    ...previousActivityInstance,
     activityType: activity.activityType,
     uiType: activity.uiType,
     uiSource: activity.uiSource,

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

@@ -1,5 +1,5 @@
 export * from './draft'
-export * from './post'
+export * from './issue'
 export * from './pick'
 export * from './assign'
 export * from './abort'

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

@@ -0,0 +1,175 @@
+import { Activity } from '../../service/activity/activity'
+import { ActivityInstance, ActivityInstanceStatus } from '../../service/activity-instance/activity-instance'
+import { ActivityInstanceIssue } from '../../service/activity-instance/activity-instance-type'
+import {
+  createActivityThreadsForAllRoleUsers,
+  createActivityThreadsForUsers,
+  getSystemUserFromOrgMemberItem,
+  createActivityThreadForUser,
+  fillActivitySearchKeys
+} from '../common'
+import { submit } from '../activity-thread/submit'
+
+export async function issue(
+  activityInstance: ActivityInstanceIssue,
+  context: ResolverContext
+): Promise<ActivityInstance> {
+  const { domain, user, tx } = context.state
+  const issuedAt = new Date()
+  var {
+    id,
+    name,
+    description,
+    assignees,
+    uiType,
+    uiSource,
+    viewType,
+    viewSource,
+    dueAt,
+    priority,
+    approvalLine,
+    activityId,
+    activityType,
+    assigneeRole,
+    supervisoryRole,
+    input
+  } = activityInstance
+
+  var origin = id
+    ? await tx.getRepository(ActivityInstance).findOne({
+        where: { domain: { id: domain.id }, id },
+        relations: [
+          'domain',
+          'activity',
+          'assigneeRole',
+          'supervisoryRole',
+          'updater',
+          'creator',
+          'starter',
+          'terminator'
+        ]
+      })
+    : null
+
+  /* 
+    Prerequisites for a Task to Be Issued.
+    - 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 issued`, {
+        id: id,
+        state: origin.state
+      })
+    )
+  }
+
+  var repository = tx.getRepository(Activity)
+  var activity =
+    origin?.activity ||
+    (await repository.findOne({
+      where: { domain: { id: domain.id }, id: activityId },
+      relations: ['assigneeRole', 'supervisoryRole']
+    }))
+
+  if (!activity) {
+    throw new Error(
+      context.t('error.activity not found', {
+        activity: activityId
+      })
+    )
+  }
+
+  if (!origin) {
+    activityInstance.name = name || activity.name
+    activityInstance.description = description || activity.description
+    activityInstance.activityType = activityType || activity.activityType
+    activityInstance.uiType = uiType || activity.uiType
+    activityInstance.uiSource = uiSource || activity.uiSource
+    activityInstance.viewType = viewType || activity.viewType
+    activityInstance.viewSource = viewSource || activity.viewSource
+    activityInstance.assigneeRole = assigneeRole || activity.assigneeRole
+    activityInstance.supervisoryRole = supervisoryRole || activity.supervisoryRole
+    activityInstance.priority = priority ?? activity.priority
+
+    if (!assignees || !approvalLine) {
+      activityInstance.adhocType = 'standard'
+      activityInstance.refBy = activityId
+      if (!assignees) {
+        assignees = activityInstance.assignees = activity.assignees
+      }
+      if (!approvalLine) {
+        approvalLine = activityInstance.approvalLine = activity.approvalLine
+      }
+
+      if (!dueAt && activity.standardTime) {
+        activityInstance.dueAt = new Date(issuedAt.getTime() + activity.standardTime * 1000)
+      }
+    }
+  }
+
+  const activitySearchKeys = fillActivitySearchKeys(activity?.searchKeys, input)
+
+  if (activity.startingType == 'post') {
+    /* 
+      startingType이 'post'이면, 
+      activityInstance 이슈와 동시에 issuer에게 할당된 activityThread가 생성되고 submit까지 모두 완료되게 된다.
+      만일, 결재선이 있다면, 상신되게 된다.
+    */
+    const posted = await tx.getRepository(ActivityInstance).save({
+      creator: user,
+      ...origin,
+      ...activityInstance,
+      transaction: 'post',
+      activity,
+      ...activitySearchKeys,
+      state: ActivityInstanceStatus.Started,
+      domain,
+      issuer: user,
+      updater: user,
+      issuedAt,
+      startedAt: issuedAt
+    })
+
+    const thread = await createActivityThreadForUser('post', posted, user, context)
+    const data = { ...activityInstance.input, ...activityInstance.output }
+    const output = (activity.model || [])
+      .filter(item => item.inout === 'inout' || item.inout === 'out')
+      .reduce((inout, item) => {
+        inout[item.name] = data[item.name]
+        return inout
+      }, {})
+
+    submit({ id: thread.id, output }, context)
+
+    return await tx.getRepository(ActivityInstance).findOneBy({ id: posted.id })
+  } else {
+    const issued = await tx.getRepository(ActivityInstance).save({
+      creator: user,
+      ...origin,
+      ...activityInstance,
+      transaction: 'issue',
+      activity,
+      ...activitySearchKeys,
+      state: ActivityInstanceStatus.Issued,
+      domain,
+      issuer: user,
+      updater: user,
+      issuedAt
+    })
+
+    const assignedUsers = await Promise.all(
+      (assignees || []).map(assignee => getSystemUserFromOrgMemberItem(assignee, context))
+    )
+
+    if (assignedUsers.length == 0 && issued.threadsMin === 0 && issued.assigneeRoleId) {
+      await createActivityThreadsForAllRoleUsers('issue', issued, context)
+    }
+
+    if (assignedUsers.length > 0) {
+      await createActivityThreadsForUsers('issue', issued, assignedUsers, context)
+    }
+
+    return await tx.getRepository(ActivityInstance).findOneBy({ id: issued.id })
+  }
+}

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

@@ -24,7 +24,7 @@ export async function pick(id: string, context: ResolverContext): Promise<Activi
     - The previous state of the task must not be Assigned.
   */
   if (
-    activityInstance.state !== ActivityInstanceStatus.Posted &&
+    activityInstance.state !== ActivityInstanceStatus.Issued &&
     activityInstance.state !== ActivityInstanceStatus.PendingAssignment
   ) {
     throw new Error(

package/server/controllers/common.ts

@@ -1,7 +1,8 @@
 import { Role, User } from '@things-factory/auth-base'
 
 import { ActivitySearchKeyItem } from '../service/activity/activity-search-key-item-type'
-import { ActivityInstance, ActivityInstanceStatus, AssigneeItem } from '../service/activity-instance/activity-instance'
+import { AssigneeItem } 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'
@@ -31,7 +32,7 @@ export async function evalActivityInstanceState(
 
   const activityInstance = await tx.getRepository(ActivityInstance).findOne({
     where: { id },
-    relations: ['activityThreads']
+    relations: ['activityThreads', 'activity']
   })
   const { threadsMin, activityThreads, state, dueAt } = activityInstance
 
@@ -46,7 +47,7 @@ export async function evalActivityInstanceState(
       return {}
     case validThreads.length === 0:
       return {
-        state: ActivityInstanceStatus.Posted
+        state: ActivityInstanceStatus.Issued
       }
     case threadsMin > validThreads.length:
       return {
@@ -79,18 +80,50 @@ export async function evalActivityInstanceState(
           ? ActivityInstanceStatus.Aborted
           : ActivityInstanceStatus.Ended,
         reason: '',
-        output: activityThreads
-          .filter(thread => (thread.state = ActivityThreadStatus.Ended))
-          .reduce((sum, thread) => {
-            sum[thread.assigneeId] = thread.output
-            return sum
-          }, {} as any),
+        output: 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, context)
+
+  return result
+}
+
 export async function createActivityThreadsForUsers(
   transaction: string,
   activityInstance: ActivityInstance,
@@ -114,6 +147,7 @@ export async function createActivityThreadsForUsers(
         activityInstance,
         domain,
         transaction,
+        output: activityInstance.output,
         creator: user,
         updater: user,
         dueAt: activityInstance.dueAt,

package/server/routes.ts

@@ -1,7 +1,7 @@
 import { logger } from '@things-factory/env'
 import { Domain, getDataSource } from '@things-factory/shell'
 import { ScheduleRegisterRequest } from '@things-factory/scheduler-client'
-import { post } from './controllers/activity-instance/post'
+import { issue } from './controllers/activity-instance/issue'
 
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
   /*
@@ -42,7 +42,7 @@ process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRout
         tx
       }
 
-      await post(
+      await issue(
         {
           activityId
         },

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

@@ -12,8 +12,7 @@ import { config } from '@things-factory/env'
 import { Domain } from '@things-factory/shell'
 import { ApprovalLineItem } from '@things-factory/organization'
 
-import { AssigneeItem } from '../activity-instance/activity-instance'
-import { Activity, ActivityStatus, ActivityType, ActivityUIType } from './activity'
+import { Activity, ActivityStartingType, ActivityStatus, ActivityType, ActivityUIType, AssigneeItem } from './activity'
 import { ActivityModelItem } from './activity-model-type'
 
 const ORMCONFIG = config.get('ormconfig', {})
@@ -75,6 +74,10 @@ export class ActivityHistory implements HistoryEntityInterface<Activity> {
   @Field({ nullable: true })
   startable?: boolean
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  startingType?: ActivityStartingType
+
   @Column({
     nullable: true
   })

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

@@ -4,8 +4,9 @@ import { Brackets } from 'typeorm'
 import { Attachment } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
 import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { ApprovalLineItem } from '@things-factory/organization'
 
-import { Activity, ActivityStatus } from './activity'
+import { Activity, ActivityStartingType, ActivityStatus, AssigneeItem } from './activity'
 import { ActivityList } from './activity-type'
 
 @Resolver(Activity)
@@ -63,7 +64,9 @@ export class ActivityQuery {
       alias: 'activity',
       searchables: ['name', 'description']
     })
-      .andWhere(`activity.startable = :startable`, { startable: true })
+      .andWhere(`activity.startingType IN (:...startingTypes)`, {
+        startingTypes: [ActivityStartingType.Issue, ActivityStartingType.Post]
+      })
       .andWhere(`activity.state = :state`, { state: ActivityStatus.Released })
       .andWhere(
         roles.length > 0
@@ -128,6 +131,86 @@ export class ActivityQuery {
     )
   }
 
+  @FieldResolver(type => [AssigneeItem])
+  async assignees(@Root() activity: Activity, @Ctx() context: ResolverContext): Promise<AssigneeItem[]> {
+    const { domain, user } = context.state
+    const { assignees } = activity
+
+    if (!assignees || !(assignees instanceof Array)) {
+      return null
+    }
+
+    var assigneeItemList = []
+
+    for (let item of assignees) {
+      var { type, value: id } = item
+      var assignee
+
+      switch (type) {
+        case 'Employee':
+          assignee = await getRepository('Employee').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Department':
+          assignee = await getRepository('Department').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Role':
+          assignee = await getRepository('Role').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Myself':
+          assignee = user
+          break
+        case 'MyDepartment':
+        case 'MySupervisor':
+          break
+        default:
+      }
+
+      assignee && assigneeItemList.push({ type, value: id, assignee })
+    }
+
+    return assigneeItemList
+  }
+
+  @FieldResolver(type => [ApprovalLineItem])
+  async approvalLine(@Root() activity: Activity, @Ctx() context: ResolverContext): Promise<ApprovalLineItem[]> {
+    const { domain, user } = context.state
+    const { approvalLine } = activity
+
+    if (!approvalLine || !(approvalLine instanceof Array)) {
+      return null
+    }
+
+    var approvalLineItems = []
+
+    for (let item of approvalLine) {
+      var { type, value: id } = item
+      var approver
+
+      switch (type) {
+        case 'Employee':
+          approver = await getRepository('Employee').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Department':
+          approver = await getRepository('Department').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Role':
+          approver = await getRepository('Role').findOneBy({ domain: { id: domain.id }, id })
+          break
+        case 'Myself':
+          approver = user
+          break
+        case 'MyDepartment':
+        case 'MySupervisor':
+          break
+        default:
+      }
+
+      approver && approvalLineItems.push({ type, value: id, approver })
+    }
+
+    return approvalLineItems
+  }
+
   @FieldResolver(type => Role)
   async supervisoryRole(@Root() activity: Activity): Promise<Role> {
     return (