@things-factory/worklist 6.0.12 → 6.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "6.0.12",
+  "version": "6.0.16",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -30,8 +30,8 @@
     "@things-factory/attachment-base": "^6.0.12",
     "@things-factory/auth-base": "^6.0.12",
     "@things-factory/board-service": "^6.0.12",
-    "@things-factory/organization": "^6.0.12",
+    "@things-factory/organization": "^6.0.15",
     "@things-factory/shell": "^6.0.12"
   },
-  "gitHead": "6dd9637de0444917aa5a3621ce1f361cfb483f36"
+  "gitHead": "b133bc7f47a51e8ad177c0c519ec136e27ab02e1"
 }

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

@@ -12,8 +12,7 @@ export async function approve(
   var repository = tx.getRepository(ActivityApproval)
 
   var activityApproval = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityThread', 'updater', 'creator']
+    where: { domain: { id: domain.id }, id }
   })
 
   if (!activityApproval) {
@@ -26,7 +25,7 @@ export async function approve(
 
   const activityThread = await tx.getRepository(ActivityThread).findOne({
     where: { domain: { id: domain.id }, id: activityApproval.activityThreadId },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    relations: ['activityInstance']
   })
 
   const approvalLine: ApprovalLineItem[] = activityThread.activityInstance.approvalLine
@@ -37,7 +36,9 @@ export async function approve(
     judgment: approvalLine[order] ? ActivityApprovalJudgment.Escalated : ActivityApprovalJudgment.Approved,
     comment,
     transaction: approvalLine[order] ? 'escalate' : 'approve',
-    updater: user
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
   })
 
   if (approvalLine && approvalLine.length > order) {

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

@@ -1,7 +1,9 @@
+import { User } from '@things-factory/auth-base'
+import { ObjectRef } from '@things-factory/shell'
 import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
 
 export async function delegate(
-  { id, comment }: { id: string; comment: string },
+  { id, to, comment }: { id: string; to: ObjectRef; comment: string },
   context: ResolverContext
 ): Promise<ActivityApproval> {
   const { domain, user, tx } = context.state
@@ -9,8 +11,7 @@ export async function delegate(
   var repository = tx.getRepository(ActivityApproval)
 
   var activityApproval = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityThread', 'updater', 'creator']
+    where: { domain: { id: domain.id }, id }
   })
 
   if (!activityApproval) {
@@ -21,13 +22,27 @@ export async function delegate(
     )
   }
 
+  /* TODO user validation .. */
+  const approver = await tx.getRepository(User).findOneBy({ id: to.id })
+
+  /* create new delegated approval */
+  await repository.save({
+    ...activityApproval,
+    originalApproval: activityApproval,
+    comment,
+    approver,
+    creator: user,
+    updater: user
+  })
+
+  /* terminate origin approval */
   return await repository.save({
     ...activityApproval,
     judgment: ActivityApprovalJudgment.Delegated,
     comment,
-    transaction: 'abort',
+    transaction: 'delegate',
     updater: user,
-    terminatedAt: new Date(),
-    terminator: user
+    terminator: user,
+    terminatedAt: new Date()
   })
 }

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

@@ -1,3 +1,4 @@
+import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
 import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
 
 export async function reject(
@@ -10,7 +11,7 @@ export async function reject(
 
   var activityApproval = await repository.findOne({
     where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityThread', 'updater', 'creator']
+    relations: ['activityThread']
   })
 
   if (!activityApproval) {
@@ -21,9 +22,7 @@ export async function reject(
     )
   }
 
-  // TODO reject activityThread here..
-
-  return await repository.save({
+  var result = await repository.save({
     ...activityApproval,
     judgment: ActivityApprovalJudgment.Rejected,
     comment,
@@ -32,4 +31,13 @@ export async function reject(
     terminatedAt: new Date(),
     terminator: user
   })
+
+  await tx.getRepository(ActivityThread).save({
+    ...activityApproval.activityThread,
+    transaction: 'reject',
+    state: ActivityThreadStatus.Rejected,
+    updater: user
+  })
+
+  return result
 }

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

@@ -20,13 +20,12 @@ export async function delegate(
   const repository = tx.getRepository(ActivityThread)
 
   var activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    where: { domain: { id: domain.id }, id }
   })
 
   if (!activityThread) {
     throw new Error(
-      context.t('error.activity-instance not found', {
+      context.t('error.activity-thread not found', {
         activityThread: id
       })
     )

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

@@ -10,8 +10,7 @@ export async function end(
   const repository = tx.getRepository(ActivityThread)
 
   var activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    where: { domain: { id: domain.id }, id }
   })
 
   if (!activityThread) {

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

@@ -4,5 +4,6 @@ export * from './end'
 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

@@ -0,0 +1,42 @@
+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
+      })
+    )
+  }
+
+  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, context)
+
+  return result
+}

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

@@ -7,10 +7,17 @@ export async function save(id: string, save: ActivityThreadSave, context: Resolv
   const repository = tx.getRepository(ActivityThread)
 
   const activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    where: { domain: { id: domain.id }, id }
   })
 
+  if (!activityThread) {
+    throw new Error(
+      context.t('error.activity-thread not found', {
+        activityThread: id
+      })
+    )
+  }
+
   const result = await repository.save({
     ...activityThread,
     ...save,

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

@@ -11,14 +11,13 @@ export async function start(
 
   const repository = tx.getRepository(ActivityThread)
   const activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    where: { domain: { id: domain.id }, id }
   })
 
   if (!activityThread) {
     throw new Error(
-      context.t('error.activity-instance not found', {
-        activityInstance: id
+      context.t('error.activity-thread not found', {
+        activityThread: id
       })
     )
   }

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

@@ -14,7 +14,7 @@ export async function submit(
 
   var activityThread = await repository.findOne({
     where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    relations: ['activityInstance']
   })
 
   if (!activityThread) {
@@ -37,6 +37,7 @@ export async function submit(
     await tx.getRepository(ActivityApproval).save({
       domain,
       activityThread,
+      round: activityThread.round,
       order: 1,
       judgment: ActivityApprovalJudgment.Pending,
       transaction: 'submit',

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

@@ -9,13 +9,12 @@ export async function terminate(
   var repository = tx.getRepository(ActivityThread)
 
   var activityThread = await repository.findOne({
-    where: { domain: { id: domain.id }, id },
-    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+    where: { domain: { id: domain.id }, id }
   })
 
   if (!activityThread) {
     throw new Error(
-      context.t('error.activity-instance not found', {
+      context.t('error.activity-thread not found', {
         activityThread: id
       })
     )

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

@@ -1,9 +1,10 @@
 import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
 
 import { ActivityApproval, ActivityApprovalJudgment } from './activity-approval'
-import { abort } from '../../controllers/activity-approval/abort'
 import { reject } from '../../controllers/activity-approval/reject'
 import { approve } from '../../controllers/activity-approval/approve'
+import { delegate } from '../../controllers/activity-approval/delegate'
+import { ObjectRef } from '@things-factory/shell'
 
 @Resolver(ActivityApproval)
 export class ActivityApprovalMutation {
@@ -60,12 +61,13 @@ export class ActivityApprovalMutation {
   }
 
   @Directive('@transaction')
-  @Mutation(returns => ActivityApproval!, { nullable: true, description: 'To abort ActivityApproval' })
-  async abortActivityApproval(
+  @Mutation(returns => ActivityApproval!, { nullable: true, description: 'To delegate ActivityApproval' })
+  async delegateActivityApproval(
     @Arg('id') id: string,
+    @Arg('to', type => ObjectRef) to: ObjectRef,
     @Arg('comment', { nullable: true }) comment: string,
     @Ctx() context: ResolverContext
   ): Promise<ActivityApproval> {
-    return await abort({ id, comment }, context)
+    return await delegate({ id, to, comment }, context)
   }
 }

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

@@ -33,7 +33,7 @@ export class ActivityApprovalQuery {
     return { items, total }
   }
 
-  @Query(returns => ActivityApprovalList, { description: 'To fetch my own ActivityApprovals' })
+  @Query(returns => ActivityApprovalList, { description: 'To fetch the list of work results I need to review' })
   async approvalWaitingList(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityApprovalList> {
     var { domain, user } = context.state
 
@@ -78,6 +78,11 @@ export class ActivityApprovalQuery {
     return await getRepository(Domain).findOneBy({ id: activityApproval.domainId })
   }
 
+  @FieldResolver(type => User)
+  async approver(@Root() activityApproval: ActivityApproval): Promise<User> {
+    return await getRepository(User).findOneBy({ id: activityApproval.approverId })
+  }
+
   @FieldResolver(type => User)
   async updater(@Root() activityApproval: ActivityApproval): Promise<User> {
     return await getRepository(User).findOneBy({ id: activityApproval.updaterId })
@@ -87,4 +92,9 @@ export class ActivityApprovalQuery {
   async creator(@Root() activityApproval: ActivityApproval): Promise<User> {
     return await getRepository(User).findOneBy({ id: activityApproval.creatorId })
   }
+
+  @FieldResolver(type => User)
+  async terminator(@Root() activityApproval: ActivityApproval): Promise<User> {
+    return await getRepository(User).findOneBy({ id: activityApproval.terminatorId })
+  }
 }

package/server/service/activity-approval/activity-approval-subscription.ts

@@ -0,0 +1,46 @@
+import { withFilter } from 'graphql-subscriptions'
+import { Resolver, Root, Subscription } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository, pubsub } from '@things-factory/shell'
+
+import { ActivityApproval } from './activity-approval'
+
+@Resolver(ActivityApproval)
+export class ActivityApprovalSubscription {
+  @Subscription({
+    subscribe: (_, args, context, info) => {
+      const { domain, user } = context.state
+      const subdomain = domain?.subdomain
+
+      if (!domain) {
+        throw new Error('domain required')
+      }
+
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
+        throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
+      }
+
+      return withFilter(
+        () => pubsub.asyncIterator('activity-approval'),
+        async (payload, variables, context, info) => {
+          const { activityApproval } = payload
+          const { domainId } = activityApproval
+
+          if (domainId !== domain?.id) {
+            return false
+          }
+
+          if (activityApproval.approverId === user.id) {
+            return true
+          }
+
+          return false
+        }
+      )(_, args, context, info)
+    }
+  })
+  activityApproval(@Root() payload: { activityApproval: ActivityApproval }): ActivityApproval {
+    return payload.activityApproval
+  }
+}

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

@@ -6,6 +6,7 @@ import {
   Column,
   RelationId,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn
 } from 'typeorm'
 import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
@@ -53,6 +54,17 @@ export class ActivityApproval {
   @RelationId((activityApproval: ActivityApproval) => activityApproval.domain)
   domainId?: string
 
+  @ManyToOne(type => ActivityApproval, { nullable: true })
+  @Field(type => ActivityApproval, { nullable: true })
+  originalApproval?: ActivityApproval
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.originalApproval)
+  originalApprovalId?: string
+
+  @OneToMany(type => ActivityApproval, activityApproval => activityApproval.originalApproval)
+  @Field(type => [ActivityApproval])
+  derivedApprovals?: ActivityApproval
+
   @ManyToOne(type => ActivityThread, { nullable: true })
   @Field(type => ActivityThread, { nullable: true })
   activityThread?: ActivityThread
@@ -60,6 +72,10 @@ export class ActivityApproval {
   @RelationId((activityApproval: ActivityApproval) => activityApproval.activityThread)
   activityThreadId?: string
 
+  @Column({ nullable: true, default: 1 })
+  @Field({ nullable: true })
+  round: number = 1
+
   @Column({ nullable: true, default: 0 })
   @Field({ nullable: true, description: 'Nth order approval for given activity thread' })
   order?: number = 0

package/server/service/activity-approval/index.ts

@@ -1,8 +1,9 @@
 import { ActivityApproval } from './activity-approval'
 import { ActivityApprovalQuery } from './activity-approval-query'
 import { ActivityApprovalMutation } from './activity-approval-mutation'
+import { ActivityApprovalSubscription } from './activity-approval-subscription'
 import { ActivityApprovalSubscriber } from './event-subscriber'
 
 export const entities = [ActivityApproval]
-export const resolvers = [ActivityApprovalQuery, ActivityApprovalMutation]
+export const resolvers = [ActivityApprovalQuery, ActivityApprovalMutation, ActivityApprovalSubscription]
 export const subscribers = [ActivityApprovalSubscriber]

package/server/service/activity-instance/activity-instance-subscription.ts

@@ -25,9 +25,9 @@ export class ActivityInstanceSubscription {
         () => pubsub.asyncIterator('activity-instance'),
         async (payload, variables, context, info) => {
           const { activityInstance } = payload
-          const { domain } = activityInstance
+          const { domainId } = activityInstance
 
-          if (subdomain !== domain?.subdomain) {
+          if (domainId !== domain?.id) {
             return false
           }
 

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

@@ -0,0 +1,132 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { getQueryBuilderFromListParams, getRepository } from '@things-factory/shell'
+
+import { ActivitySummary } from './activity-summary'
+import { ActivityThread, ActivityThreadStatus } from '../activity-thread/activity-thread'
+import { ActivityApproval, ActivityApprovalJudgment } from '../activity-approval/activity-approval'
+import { ActivityInstance, ActivityInstanceStatus } from '../activity-instance/activity-instance'
+
+@Resolver(ActivitySummary)
+export class ActivitySummaryQuery {
+  @Query(returns => ActivitySummary!, { nullable: true, description: 'To fetch a Activity Summary' })
+  async activitySummary(@Ctx() context: ResolverContext): Promise<ActivitySummary> {
+    return {}
+  }
+
+  @FieldResolver(type => Number)
+  async numberOfToDos(@Root() activitySummary: ActivitySummary, @Ctx() context: ResolverContext): Promise<number> {
+    var { domain, user } = context.state
+
+    const status = [ActivityThreadStatus.Ended, ActivityThreadStatus.Aborted]
+
+    return await getQueryBuilderFromListParams({
+      repository: getRepository(ActivityThread),
+      params: {},
+      domain,
+      alias: 'at',
+      searchables: ['name', 'description'],
+      filtersMap: {
+        name: { columnName: 'name', relationColumn: 'activityInstance' },
+        description: { columnName: 'description', relationColumn: 'activityInstance' }
+      }
+    })
+      .andWhere('at.state NOT IN (:...status)', { status })
+      .andWhere('at.assignee = :user', { user: user.id })
+      .getCount()
+  }
+
+  @FieldResolver(type => Number)
+  async numberOfApprovalWaitings(
+    @Root() activitySummary: ActivitySummary,
+    @Ctx() context: ResolverContext
+  ): Promise<number> {
+    var { domain, user } = context.state
+
+    const judgment = [
+      ActivityApprovalJudgment.Escalated,
+      ActivityApprovalJudgment.Delegated,
+      ActivityApprovalJudgment.Approved,
+      ActivityApprovalJudgment.Rejected
+    ]
+
+    return await getQueryBuilderFromListParams({
+      repository: getRepository(ActivityApproval),
+      params: {},
+      domain,
+      alias: 'ap',
+      searchables: ['name', 'description'],
+      filtersMap: {
+        name: {
+          relationColumn: 'activityThread.activityInstance',
+          columnName: 'name'
+        },
+        description: {
+          relationColumn: 'activityThread.activityInstance',
+          columnName: 'description'
+        }
+      }
+    })
+      .andWhere('ap.judgment NOT IN (:...judgment)', { judgment })
+      .andWhere('ap.approver = :user', { user: user.id })
+      .getCount()
+  }
+
+  @FieldResolver(type => Number)
+  async numberOfPicks(@Root() activitySummary: ActivitySummary, @Ctx() context: ResolverContext): Promise<number> {
+    var { domain, user } = context.state
+
+    /* 
+      activity-instance 중에서 아직 created 상태이면서, 
+      activity-instance의 assigneeRole 이 지정되지 않았거나,
+      assigneeRole이 지정되었으면 그 Role에 내가 해당된 경우이면서,
+      나는 아직 해당 activity-instance의 thread를 할당받지 않은 경우에 해당하는
+      activity-instance 리스트를 모두 가져오는 쿼리이다.
+    */
+
+    user = await getRepository(User).findOne({
+      where: { id: user.id },
+      relations: ['roles']
+    })
+    const roles = user.roles.filter(role => role.domainId === domain.id).map(role => role.id)
+
+    if (!roles.length) {
+      return 0
+    }
+
+    return await getQueryBuilderFromListParams({
+      repository: getRepository(ActivityInstance),
+      params: {},
+      domain,
+      alias: 'ai',
+      searchables: ['name', 'description']
+    })
+      .leftJoinAndSelect('ai.activityThreads', 'threads', 'threads.assignee = :user', { user: user.id })
+      .andWhere('ai.state IN (:...status)', {
+        status: [ActivityInstanceStatus.Posted, ActivityInstanceStatus.WaitingAssignment]
+      })
+      .andWhere('ai.assigneeRole IN (:...roles)', { roles })
+      .andWhere('threads.id IS NULL') /* 이미 내가 할당된 경우는 제외한다. */
+      .getCount()
+  }
+
+  @FieldResolver(type => Number)
+  async numberOfDrafts(@Root() activitySummary: ActivitySummary, @Ctx() context: ResolverContext): Promise<number> {
+    var { domain, user } = context.state
+
+    /* 생성자가 자신이면서, 아직 Draft 상태인 activity-instance 리스트만 반환 */
+    const status = [ActivityInstanceStatus.Draft]
+
+    return await getQueryBuilderFromListParams({
+      repository: getRepository(ActivityInstance),
+      params: {},
+      domain,
+      alias: 'ai',
+      searchables: ['name', 'description']
+    })
+      .andWhere('ai.state IN (:...status)', { status })
+      .andWhere('ai.creator = :user', { user: user.id })
+      .getCount()
+  }
+}

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

@@ -0,0 +1,16 @@
+import { Field, ObjectType } from 'type-graphql'
+
+@ObjectType({ description: 'Object Type for My Activity Summary' })
+export class ActivitySummary {
+  @Field({ nullable: true })
+  numberOfToDos?: number
+
+  @Field({ nullable: true })
+  numberOfApprovalWaitings?: number
+
+  @Field({ nullable: true })
+  numberOfPicks?: number
+
+  @Field({ nullable: true })
+  numberOfDrafts?: number
+}

package/server/service/activity-summary/index.ts

@@ -0,0 +1,5 @@
+import { ActivitySummary } from './activity-summary'
+import { ActivitySummaryQuery } from './activity-summary-query'
+
+export const entities = [ActivitySummary]
+export const resolvers = [ActivitySummaryQuery]