@things-factory/worklist 5.0.11 → 6.0.0-alpha.0

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

@@ -12,7 +12,7 @@ export class ActivityTemplateMutation {
   @Mutation(returns => ActivityTemplate, { description: 'To create new ActivityTemplate' })
   async createActivityTemplate(
     @Arg('activityTemplate') activityTemplate: NewActivityTemplate,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityTemplate> {
     const { domain, user, tx } = context.state
 
@@ -45,13 +45,13 @@ export class ActivityTemplateMutation {
   async updateActivityTemplate(
     @Arg('id') id: string,
     @Arg('patch') patch: ActivityTemplatePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityTemplate> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(ActivityTemplate)
     const activityTemplate = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     const result = await repository.save({
@@ -82,7 +82,7 @@ export class ActivityTemplateMutation {
   @Mutation(returns => [ActivityTemplate], { description: "To modify multiple ActivityTemplates' information" })
   async updateMultipleActivityTemplate(
     @Arg('patches', type => [ActivityTemplatePatch]) patches: ActivityTemplatePatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityTemplate[]> {
     const { domain, user, tx } = context.state
 
@@ -123,7 +123,7 @@ export class ActivityTemplateMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const activityTemplate = await activityTemplateRepo.findOne(newRecord.id)
+        const activityTemplate = await activityTemplateRepo.findOneBy({ id: newRecord.id })
 
         const result = await activityTemplateRepo.save({
           ...activityTemplate,
@@ -155,10 +155,10 @@ export class ActivityTemplateMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete ActivityTemplate' })
-  async deleteActivityTemplate(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteActivityTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(ActivityTemplate).delete({ domain, id })
+    await tx.getRepository(ActivityTemplate).delete({ domain: { id: domain.id }, id })
     await deleteAttachmentsByRef(null, { refBys: [id] }, context)
 
     return true
@@ -166,11 +166,14 @@ export class ActivityTemplateMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple ActivityTemplates' })
-  async deleteActivityTemplates(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteActivityTemplates(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(ActivityTemplate).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -183,7 +186,7 @@ export class ActivityTemplateMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple ActivityTemplates' })
   async importActivityTemplates(
     @Arg('activityTemplates', type => [ActivityTemplatePatch]) activityTemplates: ActivityTemplatePatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 

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

@@ -1,26 +1,26 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
+import { ActivityModelItem } from '../activity/activity-model-type'
 import { ActivityTemplate } from './activity-template'
 import { ActivityTemplateList } from './activity-template-type'
 
 @Resolver(ActivityTemplate)
 export class ActivityTemplateQuery {
   @Query(returns => ActivityTemplate!, { nullable: true, description: 'To fetch a ActivityTemplate' })
-  async activityTemplate(@Arg('id') id: string, @Ctx() context: any): Promise<ActivityTemplate> {
+  async activityTemplate(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityTemplate> {
     const { domain } = context.state
 
     return await getRepository(ActivityTemplate).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => ActivityTemplateList, { description: 'To fetch multiple ActivityTemplates' })
-  async activityTemplates(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityTemplateList> {
+  async activityTemplates(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityTemplateList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -35,11 +35,20 @@ export class ActivityTemplateQuery {
     return { items, total }
   }
 
+  @FieldResolver(type => [ActivityModelItem])
+  async model(@Root() activityTemplate: ActivityTemplate): Promise<ActivityModelItem[]> {
+    if (activityTemplate.model instanceof Array) {
+      return activityTemplate.model.filter(model => model.name)
+    }
+
+    return []
+  }
+
   @FieldResolver(type => String)
   async thumbnail(@Root() activityTemplate: ActivityTemplate): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
-        domain: activityTemplate.domainId,
+        domain: { id: activityTemplate.domainId },
         refType: ActivityTemplate.name,
         refBy: activityTemplate.id
       }
@@ -50,16 +59,16 @@ export class ActivityTemplateQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() activityTemplate: ActivityTemplate): Promise<Domain> {
-    return await getRepository(Domain).findOne(activityTemplate.domainId)
+    return await getRepository(Domain).findOneBy({ id: activityTemplate.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() activityTemplate: ActivityTemplate): Promise<User> {
-    return await getRepository(User).findOne(activityTemplate.updaterId)
+    return await getRepository(User).findOneBy({ id: activityTemplate.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() activityTemplate: ActivityTemplate): Promise<User> {
-    return await getRepository(User).findOne(activityTemplate.creatorId)
+    return await getRepository(User).findOneBy({ id: activityTemplate.creatorId })
   }
 }

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

@@ -13,7 +13,7 @@ export class ActivityThreadMutation {
   @Mutation(returns => ActivityThread, { description: 'To create new ActivityThread' })
   async createActivityThread(
     @Arg('activityThread') activityThread: NewActivityThread,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
     const { domain, user, tx } = context.state
 
@@ -30,13 +30,14 @@ export class ActivityThreadMutation {
   async updateActivityThread(
     @Arg('id') id: string,
     @Arg('patch') patch: ActivityThreadPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(ActivityThread)
     const activityThread = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
     })
 
     return await repository.save({
@@ -50,7 +51,7 @@ export class ActivityThreadMutation {
   @Mutation(returns => [ActivityThread], { description: "To modify multiple ActivityThreads' information" })
   async updateMultipleActivityThread(
     @Arg('patches', type => [ActivityThreadPatch]) patches: ActivityThreadPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread[]> {
     const { domain, user, tx } = context.state
 
@@ -77,7 +78,10 @@ export class ActivityThreadMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const activityThread = await activityThreadRepo.findOne(newRecord.id)
+        const activityThread = await activityThreadRepo.findOne({
+          where: { domain: { id: domain.id }, id: newRecord.id },
+          relations: ['domain', 'activityInstance', 'assignee', 'creator', 'updater']
+        })
 
         const result = await activityThreadRepo.save({
           ...activityThread,
@@ -94,20 +98,23 @@ export class ActivityThreadMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete ActivityThread' })
-  async deleteActivityThread(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteActivityThread(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(ActivityThread).delete({ domain, id })
+    await tx.getRepository(ActivityThread).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple ActivityThreads' })
-  async deleteActivityThreads(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteActivityThreads(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(ActivityThread).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -118,7 +125,7 @@ export class ActivityThreadMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple ActivityThreads' })
   async importActivityThreads(
     @Arg('activityThreads', type => [ActivityThreadPatch]) activityThreads: ActivityThreadPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
@@ -141,9 +148,9 @@ export class ActivityThreadMutation {
     @Arg('id') id: string,
     @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
-    return await start(id, output, reason, context.state)
+    return await start(id, output, reason, context)
   }
 
   @Directive('@transaction')
@@ -153,9 +160,9 @@ export class ActivityThreadMutation {
     @Arg('assigneeRole', type => ObjectRef, { nullable: true }) assigneeRole: ObjectRef,
     @Arg('dueAt', { nullable: true }) dueAt: Date,
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
-    return await delegate({ id, assigneeRole, dueAt, reason }, context.state)
+    return await delegate({ id, assigneeRole, dueAt, reason }, context)
   }
 
   @Directive('@transaction')
@@ -163,9 +170,9 @@ export class ActivityThreadMutation {
   async saveActivityThread(
     @Arg('id') id: string,
     @Arg('save') save: ActivityThreadSave,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
-    return await saveActivityThread(id, save, context.state)
+    return await saveActivityThread(id, save, context)
   }
 
   @Directive('@transaction')
@@ -174,9 +181,9 @@ export class ActivityThreadMutation {
     @Arg('id') id: string,
     @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
-    return await end({ id, output, reason }, context.state)
+    return await end({ id, output, reason }, context)
   }
 
   @Directive('@transaction')
@@ -184,8 +191,8 @@ export class ActivityThreadMutation {
   async abortActivityThread(
     @Arg('id') id: string,
     @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ActivityThread> {
-    return await abort({ id, reason }, context.state)
+    return await abort({ id, reason }, context)
   }
 }

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { ActivityInstance } from '../activity-instance/activity-instance'
 import { ActivityThread, ActivityThreadStatus } from './activity-thread'
@@ -11,16 +10,16 @@ import { ActivityThreadList } from './activity-thread-type'
 @Resolver(ActivityThread)
 export class ActivityThreadQuery {
   @Query(returns => ActivityThread!, { nullable: true, description: 'To fetch a ActivityThread' })
-  async activityThread(@Arg('id') id: string, @Ctx() context: any): Promise<ActivityThread> {
+  async activityThread(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityThread> {
     const { domain } = context.state
 
     return await getRepository(ActivityThread).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => ActivityThreadList, { description: 'To fetch multiple ActivityThreads' })
-  async activityThreads(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityThreadList> {
+  async activityThreads(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityThreadList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -36,7 +35,7 @@ export class ActivityThreadQuery {
   }
 
   @Query(returns => ActivityThreadList, { description: 'To fetch my own ActivityThreads' })
-  async todoList(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityThreadList> {
+  async todoList(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ActivityThreadList> {
     var { domain, user } = context.state
 
     const status = [ActivityThreadStatus.Assigned, ActivityThreadStatus.Started]
@@ -62,27 +61,27 @@ export class ActivityThreadQuery {
   @FieldResolver(type => User)
   async assignee(@Root() activityThread: ActivityThread): Promise<User> {
     return activityThread.assigneeId
-      ? activityThread.assignee || (await getRepository(User).findOne(activityThread.assigneeId))
+      ? activityThread.assignee || (await getRepository(User).findOneBy({ id: activityThread.assigneeId }))
       : null
   }
 
   @FieldResolver(type => ActivityInstance)
   async activityInstance(@Root() activityThread: ActivityThread): Promise<ActivityInstance> {
-    return await getRepository(ActivityInstance).findOne(activityThread.activityInstanceId)
+    return await getRepository(ActivityInstance).findOneBy({ id: activityThread.activityInstanceId })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() activityThread: ActivityThread): Promise<Domain> {
-    return await getRepository(Domain).findOne(activityThread.domainId)
+    return await getRepository(Domain).findOneBy({ id: activityThread.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() activityThread: ActivityThread): Promise<User> {
-    return await getRepository(User).findOne(activityThread.updaterId)
+    return await getRepository(User).findOneBy({ id: activityThread.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() activityThread: ActivityThread): Promise<User> {
-    return await getRepository(User).findOne(activityThread.creatorId)
+    return await getRepository(User).findOneBy({ id: activityThread.creatorId })
   }
 }

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

@@ -14,8 +14,12 @@ export class ActivityThreadSubscriber implements EntitySubscriberInterface<Activ
 
   async afterInsert(event: InsertEvent<ActivityThread>): Promise<any> {
     const activityThread = event.entity
+    const { domain, creator: user } = activityThread
 
-    await updateActivityInstanceState(activityThread.activityInstanceId, { tx: event.manager })
+    await updateActivityInstanceState(activityThread.activityInstanceId, {
+      state: { tx: event.manager, domain, user },
+      t: null
+    })
 
     pubsub.publish('activity-thread', {
       activityThread
@@ -26,8 +30,12 @@ export class ActivityThreadSubscriber implements EntitySubscriberInterface<Activ
 
   async afterUpdate(event: UpdateEvent<ActivityThread>): Promise<any> {
     const activityThread = event.entity
+    const { domain, updater: user } = activityThread
 
-    await updateActivityInstanceState(activityThread.activityInstanceId, { tx: event.manager })
+    await updateActivityInstanceState(activityThread.activityInstanceId, {
+      state: { tx: event.manager, domain, user },
+      t: null
+    })
 
     pubsub.publish('activity-thread', {
       activityThread
@@ -37,7 +45,11 @@ export class ActivityThreadSubscriber implements EntitySubscriberInterface<Activ
 
   async afterRemove(event: RemoveEvent<ActivityThread>): Promise<any> {
     const activityThread = event.entity
+    const { domain, updater: user } = activityThread
 
-    await updateActivityInstanceState(activityThread.activityInstanceId, { tx: event.manager })
+    await updateActivityInstanceState(activityThread.activityInstanceId, {
+      state: { tx: event.manager, domain, user },
+      t: null
+    })
   }
 }

package/translations/en.json

@@ -1,6 +1,9 @@
 {
   "button.assign": "assign",
+  "button.buy": "buy",
+  "button.draft": "draft",
   "button.finish": "finish",
+  "button.post": "post",
   "button.start": "start",
   "field.activity-type": "activity type",
   "field.assignee": "assignee",

package/translations/ko.json

@@ -1,6 +1,9 @@
 {
   "button.assign": "할당",
+  "button.buy": "구매",
+  "button.draft": "초안",
   "button.finish": "완료",
+  "button.post": "게시",
   "button.start": "시작",
   "field.activity-type": "업무 타입",
   "field.assignee": "피할당자",

package/translations/ms.json

@@ -1,6 +1,9 @@
 {
   "button.assign": "assign",
+  "button.buy": "buy",
+  "button.draft": "draft",
   "button.finish": "finish",
+  "button.post": "post",
   "button.start": "start",
   "field.activity-type": "activity type",
   "field.assignee": "assignee",

package/translations/zh.json

@@ -1,6 +1,9 @@
 {
   "button.assign": "assign",
+  "button.buy": "buy",
+  "button.draft": "draft",
   "button.finish": "finish",
+  "button.post": "post",
   "button.start": "start",
   "field.activity-type": "activity type",
   "field.assignee": "assignee",