@things-factory/worklist 7.0.0-alpha.8 → 7.0.0

package/server/service/activity/activity.ts

@@ -1,261 +0,0 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn,
-  VersionColumn
-} from 'typeorm'
-
-import { Role, User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { OrgMemberTargetType, OrgMemberTarget, ApprovalLineItem } from '@things-factory/organization'
-
-import { ActivityModelItem } from './activity-model-type'
-import { ActivitySearchKeyItem } from './activity-search-key-item-type'
-
-export enum ActivityStatus {
-  Draft = 'draft',
-  Released = 'released',
-  Deprecated = 'deprecated'
-}
-
-registerEnumType(ActivityStatus, {
-  name: 'ActivityStatus',
-  description: 'state enumeration of a activity'
-})
-
-export enum ActivityStartingType {
-  None = '',
-  Post = 'post',
-  Issue = 'issue'
-}
-
-registerEnumType(ActivityStartingType, {
-  name: 'ActivityStartingType',
-  description: 'whether the purpose of starting the activity is to issue or post'
-})
-
-export enum ActivityType {
-  Task = 'task',
-  Service = 'service',
-  Send = 'send',
-  Receive = 'receive',
-  User = 'user',
-  Manual = 'manual',
-  BusinessRule = 'business-rule',
-  Script = 'script',
-  Subprocess = 'sub-process',
-  Call = 'call'
-}
-
-registerEnumType(ActivityType, {
-  name: 'ActivityType',
-  description: 'type enumeration of a activity based on BPMN 2.0'
-})
-
-export enum MultipleInstanceType {
-  Single = 'single',
-  Parallel = 'parallel',
-  Sequential = 'sequential'
-}
-
-registerEnumType(MultipleInstanceType, {
-  name: 'MultipleInstanceType',
-  description: 'type enumeration of a multiple instance property based on BPMN 2.0'
-})
-
-export enum ActivityUIType {
-  Generated = 'generated',
-  Template = 'template',
-  Board = 'board',
-  CustomElement = 'custom-element',
-  Page = 'page',
-  External = 'external'
-}
-
-registerEnumType(ActivityUIType, {
-  name: 'ActivityUIType',
-  description: 'user-interface type enumeration of a activity'
-})
-
-@ObjectType()
-export class AssigneeItem {
-  @Field(type => OrgMemberTargetType, { nullable: true })
-  type?: OrgMemberTargetType
-
-  @Field({ nullable: true })
-  value?: string
-
-  @Field(type => OrgMemberTarget, { nullable: true })
-  assignee?: OrgMemberTarget
-}
-
-@Entity()
-@Index('ix_activity_0', (activity: Activity) => [activity.domain, activity.name], { unique: true })
-@Index('ix_activity_1', (activity: Activity) => [activity.domain, activity.state, activity.priority], { unique: false })
-@ObjectType({ description: 'Entity for Activity' })
-export class Activity {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @VersionColumn()
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain?: Domain
-
-  @RelationId((activity: Activity) => activity.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'BPMN 2.0 task type' })
-  activityType?: ActivityType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ActivityStatus
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ActivitySearchKeyItem], { nullable: true })
-  searchKeys?: ActivitySearchKeyItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ActivityModelItem], { nullable: true })
-  model?: ActivityModelItem[]
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  priority?: number = 1
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Whether the purpose of starting the activity is to issue or post' })
-  startingType?: ActivityStartingType
-
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description:
-      'Parallel or sequential are properties as a multi-instance activity, otherwise it means a single instance.'
-  })
-  multiple?: MultipleInstanceType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Autostart schedule in crontab format' })
-  schedule?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'ID of the autostart schedule registered in the schedule service' })
-  scheduleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Time zone to which automatic scheduling is applied' })
-  timezone?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Standard time for this activity to be performed' })
-  standardTime?: number
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  issuerRole?: Role
-
-  @RelationId((activity: Activity) => activity.issuerRole)
-  issuerRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true, description: 'Roles eligible to pick up activity from the activity bank.' })
-  assigneeRole?: Role
-
-  @RelationId((activity: Activity) => activity.assigneeRole)
-  assigneeRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true, description: 'The final authority on a given activity.' })
-  supervisoryRole?: Role
-
-  @RelationId((activity: Activity) => activity.supervisoryRole)
-  supervisoryRoleId?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [AssigneeItem], { nullable: true, description: 'Who to resolve for the activity.' })
-  assignees?: AssigneeItem[]
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], {
-    nullable: true,
-    description: 'Approval line for handling the activity.'
-  })
-  approvalLine?: ApprovalLineItem[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of UI to be shown when a task is performed' })
-  uiType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of view to be shown when a task is approved' })
-  viewType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  viewSource?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'The type of report to be shown when a task is approved' })
-  reportType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reportSource?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User assigned to the client application' })
-  client?: User
-
-  @RelationId((activity: Activity) => activity.client)
-  clientId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((activity: Activity) => activity.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((activity: Activity) => activity.updater)
-  updaterId?: string
-
-  @Field(type => String, { nullable: true })
-  thumbnail?: string
-}

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

@@ -1,17 +0,0 @@
-import { EventSubscriber } from 'typeorm'
-
-import { HistoryEntitySubscriber } from '@operato/typeorm-history'
-
-import { Activity } from './activity'
-import { ActivityHistory } from './activity-history'
-
-@EventSubscriber()
-export class ActivityHistoryEntitySubscriber extends HistoryEntitySubscriber<Activity, ActivityHistory> {
-  public get entity() {
-    return Activity
-  }
-
-  public get historyEntity() {
-    return ActivityHistory
-  }
-}

package/server/service/activity/index.ts

@@ -1,9 +0,0 @@
-import { Activity } from './activity'
-import { ActivityHistory } from './activity-history'
-import { ActivityMutation } from './activity-mutation'
-import { ActivityQuery } from './activity-query'
-import { ActivityHistoryEntitySubscriber } from './event-subscriber'
-
-export const entities = [Activity, ActivityHistory]
-export const resolvers = [ActivityQuery, ActivityMutation]
-export const subscribers = [ActivityHistoryEntitySubscriber]

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

@@ -1,75 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-
-import { ActivityApproval } from './activity-approval'
-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 {
-  /* 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> {
-    const { t } = context
-
-    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> {
-    const { t } = context
-
-    if (!comment) {
-      throw t('text.enter a comment')
-    }
-
-    return await reject({ id, comment }, context)
-  }
-
-  @Directive('@transaction')
-  @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> {
-    const { t } = context
-
-    if (!comment) {
-      throw t('text.enter a comment')
-    }
-
-    return await delegate({ id, to, comment }, context)
-  }
-}

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

@@ -1,152 +0,0 @@
-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 { 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 the list of work results I need to review' })
-  async approvalPendingList(@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'
-        },
-        priority: {
-          relationColumn: 'activityThread.activityInstance',
-          columnName: 'priority'
-        },
-        dueAt: {
-          relationColumn: 'activityThread.activityInstance',
-          columnName: 'dueAt'
-        }
-      }
-    })
-      .andWhere('ap.judgment NOT IN (:...judgment)', { judgment })
-      .andWhere('ap.approver = :user', { user: user.id })
-      .getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => ActivityApprovalList, {
-    description: 'To fetch the approvals(ActivityApprovals) which has done by me'
-  })
-  async approvalDoneList(@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'
-        },
-        priority: {
-          relationColumn: 'activityThread.activityInstance',
-          columnName: 'priority'
-        },
-        dueAt: {
-          relationColumn: 'activityThread.activityInstance',
-          columnName: 'dueAt'
-        }
-      }
-    })
-      .andWhere('ap.judgment 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 approver(@Root() activityApproval: ActivityApproval): Promise<User> {
-    return activityApproval.approverId && (await getRepository(User).findOneBy({ id: activityApproval.approverId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() activityApproval: ActivityApproval): Promise<User> {
-    return activityApproval.updaterId && (await getRepository(User).findOneBy({ id: activityApproval.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() activityApproval: ActivityApproval): Promise<User> {
-    return activityApproval.creatorId && (await getRepository(User).findOneBy({ id: activityApproval.creatorId }))
-  }
-
-  @FieldResolver(type => User)
-  async terminator(@Root() activityApproval: ActivityApproval): Promise<User> {
-    return activityApproval.terminatorId && (await getRepository(User).findOneBy({ id: activityApproval.terminatorId }))
-  }
-}

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

@@ -1,45 +0,0 @@
-import { filter, pipe } from 'graphql-yoga'
-import { Resolver, Root, Subscription } from 'type-graphql'
-
-import { 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 pipe(
-        pubsub.subscribe('activity-approval'),
-        filter((payload: { activityApproval: ActivityApproval }) => {
-          const { activityApproval } = payload
-          const { domainId } = activityApproval
-
-          if (domainId !== domain?.id) {
-            return false
-          }
-
-          if (activityApproval.approverId === user.id) {
-            return true
-          }
-
-          return false
-        })
-      )
-    }
-  })
-  activityApproval(@Root() payload: { activityApproval: ActivityApproval }): ActivityApproval {
-    return payload.activityApproval
-  }
-}

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

@@ -1,28 +0,0 @@
-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
-}