@things-factory/worklist 6.0.8 → 6.0.12

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

@@ -0,0 +1,71 @@
+import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
+import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval'
+import { getSystemUserFromApprovalLineItem, updateActivityInstanceState } from '../common'
+import { User } from '@things-factory/auth-base'
+import { Department, Employee, ApprovalLineItem, ApprovalLineItemType } from '@things-factory/organization'
+
+export async function submit(
+  { id, output, reason }: { id: string; output?: object; reason?: string },
+  context: any
+): Promise<ActivityThread> {
+  const { domain, user, tx } = context.state
+
+  const repository = tx.getRepository(ActivityThread)
+
+  var activityThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+  })
+
+  if (!activityThread) {
+    throw new Error(
+      context.t('error.activity-thread not found', {
+        activityThread: id
+      })
+    )
+  }
+
+  const approvalLine: ApprovalLineItem[] = activityThread.activityInstance.approvalLine
+
+  if (approvalLine && approvalLine.length > 0) {
+    var approverUser = await getSystemUserFromApprovalLineItem(approvalLine[0], context)
+
+    if (!approverUser) {
+      throw 'Cannot specify the approval user for this approval line'
+    }
+
+    await tx.getRepository(ActivityApproval).save({
+      domain,
+      activityThread,
+      order: 1,
+      judgment: ActivityApprovalJudgment.Pending,
+      transaction: 'submit',
+      approver: approverUser,
+      creator: user,
+      updater: user
+    })
+
+    var result = await repository.save({
+      ...activityThread,
+      reason,
+      output,
+      transaction: 'submit',
+      state: ActivityThreadStatus.Submitted,
+      updater: user
+    })
+  } else {
+    var result = await repository.save({
+      ...activityThread,
+      reason,
+      output,
+      transaction: 'end',
+      state: ActivityThreadStatus.Ended,
+      updater: user,
+      terminatedAt: new Date()
+    })
+  }
+
+  await updateActivityInstanceState(activityThread.activityInstanceId, context)
+
+  return result
+}

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

@@ -1,5 +1,3 @@
-import { getRepository } from '@things-factory/shell'
-
 import { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread'
 import { updateActivityInstanceState } from '../common'
 
@@ -8,7 +6,7 @@ export async function terminate(
   context: any
 ): Promise<ActivityThread> {
   const { domain, user, tx } = context.state
-  var repository = getRepository(ActivityThread)
+  var repository = tx.getRepository(ActivityThread)
 
   var activityThread = await repository.findOne({
     where: { domain: { id: domain.id }, id },
@@ -23,7 +21,7 @@ export async function terminate(
     )
   }
 
-  const result = await tx.getRepository(ActivityThread).save({
+  const result = await repository.save({
     ...activityThread,
     reason,
     output,

package/server/controllers/common.ts

@@ -2,6 +2,7 @@ import { Role, User } from '@things-factory/auth-base'
 
 import { ActivityInstance, ActivityInstanceStatus } from '../service/activity-instance/activity-instance'
 import { ActivityThread, ActivityThreadStatus } from '../service/activity-thread/activity-thread'
+import { Department, Employee, ApprovalLineItem, ApprovalLineItemType } from '@things-factory/organization'
 
 export async function updateActivityInstanceState(id: string, context: ResolverContext) {
   const { tx } = context.state
@@ -109,3 +110,30 @@ export async function createActivityThreadsForAllRoleUsers(
   // create activity-thread for all of users having given role
   return await createActivityThreadsForUsers(transaction, activityInstance, assignees, context)
 }
+
+export async function getSystemUserFromApprovalLineItem(
+  approvalLineItem: ApprovalLineItem,
+  context: any
+): Promise<User> {
+  const { domain, user, tx } = context.state
+
+  const { type, value, approver } = approvalLineItem
+  const { id: approverId, name, description, controlNo } = approver
+
+  if (type == ApprovalLineItemType.Employee) {
+    const employee = await tx.getRepository(Employee).findOne({ where: { id: approverId }, relations: ['user'] })
+
+    if (!employee || !employee.user) {
+      return
+    }
+    return employee.user
+  } else if (type == ApprovalLineItemType.Department) {
+    const department = await tx.getRepository(Department).findOne({ where: { id: approverId }, relations: ['manager'] })
+
+    if (!department || !department.manager) {
+      return
+    }
+    return await tx.getRepository(User).findOneBy({ id: department.manager.userId })
+  } else if (type == ApprovalLineItemType.Role) {
+  }
+}

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

@@ -35,7 +35,7 @@ export class ActivityQuery {
     const queryBuilder = getQueryBuilderFromListParams({
       domain,
       params,
-      repository: await getRepository(Activity),
+      repository: getRepository(Activity),
       alias: 'activity',
       searchables: ['name', 'description', 'issuerRole', 'assigneeRole', 'supervisoryRole']
     })

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

@@ -0,0 +1,71 @@
+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'
+
+@Resolver(ActivityApproval)
+export class ActivityApprovalMutation {
+  /* transactions ... */
+
+  @Directive('@transaction')
+  @Mutation(returns => ActivityApproval!, { nullable: true, description: 'To approve ActivityApproval' })
+  async saveActivityApproval(
+    @Arg('id') id: string,
+    @Arg('comment', { nullable: true }) comment: string,
+    @Ctx() 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 }
+    })
+
+    if (!activityApproval) {
+      throw new Error(
+        context.t('error.activity-approval not found', {
+          activityApproval: id
+        })
+      )
+    }
+
+    return await repository.save({
+      ...activityApproval,
+      comment,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ActivityApproval!, { nullable: true, description: 'To approve ActivityApproval' })
+  async approveActivityApproval(
+    @Arg('id') id: string,
+    @Arg('comment', { nullable: true }) comment: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ActivityApproval> {
+    return await approve({ id, comment }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ActivityApproval!, { nullable: true, description: 'To reject ActivityApproval' })
+  async rejectActivityApproval(
+    @Arg('id') id: string,
+    @Arg('comment', { nullable: true }) comment: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ActivityApproval> {
+    return await reject({ id, comment }, context)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ActivityApproval!, { nullable: true, description: 'To abort ActivityApproval' })
+  async abortActivityApproval(
+    @Arg('id') id: string,
+    @Arg('comment', { nullable: true }) comment: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ActivityApproval> {
+    return await abort({ id, comment }, context)
+  }
+}

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

@@ -0,0 +1,90 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ActivityInstance } from '../activity-instance/activity-instance'
+import { ActivityThread } from '../activity-thread/activity-thread'
+import { ActivityApproval, ActivityApprovalJudgment } from './activity-approval'
+import { ActivityApprovalList } from './activity-approval-type'
+
+@Resolver(ActivityApproval)
+export class ActivityApprovalQuery {
+  @Query(returns => ActivityApproval!, { nullable: true, description: 'To fetch a ActivityApproval' })
+  async activityApproval(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityApproval> {
+    const { domain } = context.state
+
+    return await getRepository(ActivityApproval).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => ActivityApprovalList, { description: 'To fetch multiple ActivityApprovals' })
+  async activityApprovals(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityApprovalList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: getRepository(ActivityApproval),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Query(returns => ActivityApprovalList, { description: 'To fetch my own ActivityApprovals' })
+  async approvalWaitingList(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityApprovalList> {
+    var { domain, user } = context.state
+
+    const judgment = [
+      ActivityApprovalJudgment.Escalated,
+      ActivityApprovalJudgment.Delegated,
+      ActivityApprovalJudgment.Approved,
+      ActivityApprovalJudgment.Rejected
+    ]
+
+    const [items, total] = 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 })
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => ActivityThread)
+  async activityThread(@Root() activityApproval: ActivityApproval): Promise<ActivityThread> {
+    return await getRepository(ActivityThread).findOneBy({ id: activityApproval.activityThreadId })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() activityApproval: ActivityApproval): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: activityApproval.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() activityApproval: ActivityApproval): Promise<User> {
+    return await getRepository(User).findOneBy({ id: activityApproval.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() activityApproval: ActivityApproval): Promise<User> {
+    return await getRepository(User).findOneBy({ id: activityApproval.creatorId })
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { ActivityApproval, ActivityApprovalJudgment } from './activity-approval'
+
+@InputType()
+export class ActivityApprovalPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  judgment?: ActivityApprovalJudgment
+
+  @Field({ nullable: true })
+  comment?: string
+}
+
+@ObjectType()
+export class ActivityApprovalList {
+  @Field(type => [ActivityApproval])
+  items: ActivityApproval[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,118 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ActivityThread } from '../activity-thread/activity-thread'
+
+export enum ActivityApprovalJudgment {
+  Pending = '',
+  Rejected = 'rejected',
+  Escalated = 'escalated',
+  Delegated = 'delegated',
+  Approved = 'approved',
+  Aborted = 'aborted'
+}
+
+registerEnumType(ActivityApprovalJudgment, {
+  name: 'ActivityApprovalJudgment',
+  description: 'judgment enumeration of a activityApproval'
+})
+
+@Entity()
+@Index(
+  'ix_activity_approval_0',
+  (activityApproval: ActivityApproval) => [
+    activityApproval.domain,
+    activityApproval.activityThread,
+    activityApproval.order,
+    activityApproval.approver,
+    activityApproval.createdAt
+  ],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ActivityApproval' })
+export class ActivityApproval {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.domain)
+  domainId?: string
+
+  @ManyToOne(type => ActivityThread, { nullable: true })
+  @Field(type => ActivityThread, { nullable: true })
+  activityThread?: ActivityThread
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.activityThread)
+  activityThreadId?: string
+
+  @Column({ nullable: true, default: 0 })
+  @Field({ nullable: true, description: 'Nth order approval for given activity thread' })
+  order?: number = 0
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  approver?: User
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.approver)
+  approverId?: string
+
+  @Column({ nullable: true, default: '' })
+  @Field({ nullable: true })
+  judgment?: ActivityApprovalJudgment = ActivityApprovalJudgment.Pending
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  comment?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  transaction?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  terminatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.updater)
+  updaterId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  terminator?: User
+
+  @RelationId((activityApproval: ActivityApproval) => activityApproval.terminator)
+  terminatorId?: string
+}

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

@@ -0,0 +1,28 @@
+import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
+
+import { pubsub } from '@things-factory/shell'
+
+import { ActivityApproval } from './activity-approval'
+
+@EventSubscriber()
+export class ActivityApprovalSubscriber implements EntitySubscriberInterface<ActivityApproval> {
+  listenTo() {
+    return ActivityApproval
+  }
+
+  afterInsert(event: InsertEvent<ActivityApproval>): Promise<any> | void {
+    const activityApproval = event.entity
+
+    pubsub.publish('activity-approval', {
+      activityApproval
+    })
+  }
+
+  afterUpdate(event: UpdateEvent<ActivityApproval>): Promise<any> | void {
+    const activityApproval = event.entity
+
+    pubsub.publish('activity-approval', {
+      activityApproval
+    })
+  }
+}

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

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

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

@@ -27,7 +27,7 @@ export class ActivityInstanceQuery {
     const [items, total] = await getQueryBuilderFromListParams({
       domain,
       params,
-      repository: await getRepository(ActivityInstance),
+      repository: getRepository(ActivityInstance),
       searchables: ['name', 'description']
     }).getManyAndCount()
 

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

@@ -26,7 +26,7 @@ export class ActivityTemplateQuery {
     const queryBuilder = getQueryBuilderFromListParams({
       domain,
       params,
-      repository: await getRepository(ActivityTemplate),
+      repository: getRepository(ActivityTemplate),
       searchables: ['name', 'description']
     })
 

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

@@ -3,7 +3,7 @@ import { In } from 'typeorm'
 
 import { ObjectRef, ScalarObject } from '@things-factory/shell'
 
-import { abort, delegate, end, save as saveActivityThread, start } from '../../controllers/activity-thread'
+import { abort, delegate, end, save as saveActivityThread, start, submit } from '../../controllers/activity-thread'
 import { ActivityThread } from './activity-thread'
 import { ActivityThreadSave } from './activity-thread-type'
 
@@ -55,6 +55,17 @@ export class ActivityThreadMutation {
     return await end({ id, output, reason }, context)
   }
 
+  @Directive('@transaction')
+  @Mutation(returns => ActivityThread, { description: 'To submit a ActivityThread' })
+  async submitActivityThread(
+    @Arg('id') id: string,
+    @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
+    @Arg('reason', { nullable: true }) reason: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ActivityThread> {
+    return await submit({ id, output, reason }, context)
+  }
+
   @Directive('@transaction')
   @Mutation(returns => ActivityThread, { description: 'To abort a ActivityThread' })
   async abortActivityThread(

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

@@ -25,7 +25,7 @@ export class ActivityThreadQuery {
     const queryBuilder = getQueryBuilderFromListParams({
       domain,
       params,
-      repository: await getRepository(ActivityThread),
+      repository: getRepository(ActivityThread),
       searchables: ['name', 'description']
     })
 
@@ -38,7 +38,12 @@ export class ActivityThreadQuery {
   async todoList(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityThreadList> {
     var { domain, user } = context.state
 
-    const status = [ActivityThreadStatus.Assigned, ActivityThreadStatus.Started]
+    const status = [
+      ActivityThreadStatus.Assigned,
+      ActivityThreadStatus.Started,
+      ActivityThreadStatus.Submitted,
+      ActivityThreadStatus.Rejected
+    ]
 
     const [items, total] = await getQueryBuilderFromListParams({
       repository: getRepository(ActivityThread),

package/server/service/activity-thread/activity-thread-type.ts

@@ -3,18 +3,7 @@ import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
 import { ScalarObject } from '@things-factory/shell'
 
 import { ActivityThread, ActivityThreadStatus } from './activity-thread'
-
-@InputType()
-export class NewActivityThread {
-  @Field({ nullable: true })
-  state?: ActivityThreadStatus
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({ nullable: true })
-  params?: string
-}
+import { User } from '@things-factory/auth-base'
 
 @InputType()
 export class ActivityThreadPatch {
@@ -26,9 +15,6 @@ export class ActivityThreadPatch {
 
   @Field({ nullable: true })
   active?: boolean
-
-  @Field({ nullable: true })
-  cuFlag?: string
 }
 
 @InputType()

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

@@ -4,6 +4,7 @@ import {
   CreateDateColumn,
   Entity,
   Index,
+  OneToMany,
   ManyToOne,
   PrimaryGeneratedColumn,
   RelationId,
@@ -19,6 +20,9 @@ export enum ActivityThreadStatus {
   Assigned = 'assigned',
   Started = 'started',
   Delegated = 'delegated',
+  Submitted = 'submitted',
+  Escalated = 'escalated',
+  Rejected = 'rejected',
   Ended = 'ended',
   Aborted = 'aborted'
 }
@@ -56,6 +60,17 @@ export class ActivityThread {
   @RelationId((activityThread: ActivityThread) => activityThread.activityInstance)
   activityInstanceId?: string
 
+  @ManyToOne(type => ActivityThread, { nullable: true })
+  @Field(type => ActivityThread, { nullable: true })
+  originalThread?: ActivityThread
+
+  @RelationId((activityThread: ActivityThread) => activityThread.originalThread)
+  originalThreadId?: string
+
+  @OneToMany(type => ActivityThread, activityThread => activityThread.originalThread)
+  @Field(type => [ActivityThread])
+  derivedThreads?: ActivityThread
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   active?: boolean
@@ -113,6 +128,13 @@ export class ActivityThread {
   @RelationId((activityThread: ActivityThread) => activityThread.updater)
   updaterId?: string
 
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  terminator?: User
+
+  @RelationId((activityThread: ActivityThread) => activityThread.terminator)
+  terminatorId?: string
+
   isPendingStarted(): boolean {
     switch (this.state) {
       case ActivityThreadStatus.Assigned:
@@ -125,6 +147,7 @@ export class ActivityThread {
   isPendingEnded(): boolean {
     switch (this.state) {
       case ActivityThreadStatus.Started:
+      case ActivityThreadStatus.Rejected:
         return true
       default:
         return false
@@ -136,6 +159,7 @@ export class ActivityThread {
       case ActivityThreadStatus.Assigned:
       case ActivityThreadStatus.Started:
       case ActivityThreadStatus.Ended:
+      case ActivityThreadStatus.Rejected:
         return true
       case ActivityThreadStatus.Delegated:
       case ActivityThreadStatus.Aborted: