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

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

@@ -1,124 +0,0 @@
-import { CreateDateColumn, UpdateDateColumn, Entity, Index, Column, RelationId, ManyToOne, OneToMany, 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 => ActivityApproval, { nullable: true })
-  @Field(type => ActivityApproval, { nullable: true, description: 'delegator approval' })
-  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
-
-  @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 the 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

@@ -1,45 +0,0 @@
-import { EventSubscriber, EntitySubscriberInterface, InsertEvent, UpdateEvent } from 'typeorm'
-
-import { pubsub } from '@things-factory/shell'
-
-import { ActivityApproval } from './activity-approval'
-import { callWebhook } from '../../controllers/activity-installation/call-webhook'
-
-@EventSubscriber()
-export class ActivityApprovalSubscriber implements EntitySubscriberInterface<ActivityApproval> {
-  listenTo() {
-    return ActivityApproval
-  }
-
-  async afterInsert(event: InsertEvent<ActivityApproval>): Promise<any | void> {
-    const { manager: tx, entity } = event
-    const activityApproval = await tx.getRepository(ActivityApproval).findOne({
-      where: { id: entity.id },
-      relations: ['domain', 'activityThread']
-    })
-
-    pubsub.publish('activity-approval', {
-      activityApproval
-    })
-
-    try {
-      callWebhook(activityApproval.domain, 'activity-approval-created', activityApproval, tx)
-    } catch (err) {}
-  }
-
-  async afterUpdate(event: UpdateEvent<ActivityApproval>): Promise<any | void> {
-    const { manager: tx, entity } = event
-    const activityApproval = await tx.getRepository(ActivityApproval).findOne({
-      where: { id: entity.id },
-      relations: ['domain', 'activityThread']
-    })
-
-    pubsub.publish('activity-approval', {
-      activityApproval
-    })
-
-    try {
-      callWebhook(activityApproval.domain, 'activity-approval-updated', activityApproval, tx)
-    } catch (err) {}
-  }
-}

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

@@ -1,9 +0,0 @@
-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, ActivityApprovalSubscription]
-export const subscribers = [ActivityApprovalSubscriber]

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

@@ -1,48 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { ListParam, convertListParams, getRepository, getQueryBuilderFromListParams } from '@things-factory/shell'
-import { ActivityInstanceHistory } from './activity-instance-history'
-import { ActivityInstanceHistoryList } from './activity-instance-history-type'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-@Resolver(ActivityInstanceHistory)
-export class ActivityInstanceHistoryQuery {
-
-  @Query(returns => ActivityInstanceHistory, { description: 'To fetch a ActivityInstanceHistory' })
-  async activityInstanceHistory(@Arg('id') id: string, @Ctx() context: any): Promise<ActivityInstanceHistory> {
-    const { domain } = context.state
-    return await getRepository(ActivityInstanceHistory).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => ActivityInstanceHistoryList, { description: 'To fetch multiple ActivityInstanceHistory' })
-  async activityInstanceHistories(@Args() params: ListParam, @Ctx() context: any): Promise<ActivityInstanceHistoryList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      params,
-      domain,
-      repository: await getRepository(ActivityInstanceHistory)
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() activityInstanceHistory: ActivityInstanceHistory): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({id:activityInstanceHistory.domainId})
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() activityInstanceHistory: ActivityInstanceHistory): Promise<User> {
-    return await getRepository(User).findOneBy({id:activityInstanceHistory.updaterId})
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() activityInstanceHistory: ActivityInstanceHistory): Promise<User> {
-    return await getRepository(User).findOneBy({id:activityInstanceHistory.creatorId})
-  }
-}

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

@@ -1,13 +0,0 @@
-
-import { ObjectType, Field, InputType, Int, ID, Float, registerEnumType } from 'type-graphql'
-
-import { ActivityInstanceHistory } from './activity-instance-history'
-
-@ObjectType()
-export class ActivityInstanceHistoryList {
-  @Field(type => [ActivityInstanceHistory])
-  items: ActivityInstanceHistory[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,244 +0,0 @@
-import { Field, ID, Int, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId } from 'typeorm'
-
-import {
-  HistoryActionColumn,
-  HistoryActionType,
-  HistoryEntityInterface,
-  HistoryOriginalIdColumn
-} from '@operato/typeorm-history'
-import { Role, User } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { ApprovalLineItem } from '@things-factory/organization'
-
-import { ActivityType, ActivityUIType } from '../activity/activity'
-import { ActivityInstance, ActivityInstanceStatus } from './activity-instance'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-@Entity()
-@Index(
-  'ix_activity_instance_history_0',
-  (activityInstanceHistory: ActivityInstanceHistory) => [
-    activityInstanceHistory.originalId,
-    activityInstanceHistory.version
-  ],
-  { unique: true }
-)
-@Index(
-  'ix_activity_instance_history_1',
-  (activityInstanceHistory: ActivityInstanceHistory) => [
-    activityInstanceHistory.domain,
-    activityInstanceHistory.originalId,
-    activityInstanceHistory.version
-  ],
-  { unique: true }
-)
-@ObjectType({ description: 'History Entity of ActivityInstance' })
-export class ActivityInstanceHistory implements HistoryEntityInterface<ActivityInstance> {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @Column({
-    nullable: true,
-    default: 1
-  })
-  @Field({ nullable: true })
-  version?: number = 1
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true })
-  domain?: Domain
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.domain)
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  activityType?: ActivityType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  adhocType?: string
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  key01?: string = ''
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  key02?: string = ''
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  key03?: string = ''
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  key04?: string = ''
-
-  @Column({ nullable: true, default: '' })
-  @Field({ nullable: true })
-  key05?: string = ''
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiType?: ActivityUIType
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  uiSource?: string
-
-  @Column({ nullable: true, default: 1 })
-  @Field({ nullable: true })
-  priority?: number = 1
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state?: ActivityInstanceStatus
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  reason?: string
-
-  @Column({ nullable: true })
-  @Field(type => Int, { nullable: true })
-  threadsMin?: number
-
-  @Column({ nullable: true })
-  @Field(type => Int, { nullable: true })
-  threadsMax?: number
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  input?: { [key: string]: any }
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, { nullable: true })
-  output?: { [key: string]: any }
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refBy?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  assigneeRole?: Role
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.assigneeRole)
-  assigneeRoleId?: string
-
-  @ManyToOne(type => Role, { nullable: true })
-  @Field(type => Role, { nullable: true })
-  supervisoryRole?: Role
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.supervisoryRole)
-  supervisoryRoleId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  dueAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  transaction?: string
-
-  @Column('simple-json', { nullable: true })
-  @Field(type => [ApprovalLineItem], { nullable: true })
-  approvalLine?: ApprovalLineItem[]
-
-  @Column()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @Column()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  issuedAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  assignedAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  startedAt?: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  terminatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  creator?: User
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  updater?: User
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.updater)
-  updaterId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  issuer?: User
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.issuer)
-  issuerId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  starter?: User
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.starter)
-  starterId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field({ nullable: true })
-  terminator?: User
-
-  @RelationId((activityInstance: ActivityInstance) => activityInstance.terminator)
-  terminatorId?: string
-
-  @HistoryOriginalIdColumn()
-  public originalId!: string
-
-  @HistoryActionColumn({
-    nullable: false,
-    type:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'enum'
-        : DATABASE_TYPE == 'oracle'
-        ? 'varchar2'
-        : 'smallint',
-    enum: HistoryActionType
-  })
-  public action!: HistoryActionType
-
-  isDelegatable(): boolean {
-    switch (this.state) {
-      case ActivityInstanceStatus.Issued:
-      case ActivityInstanceStatus.Assigned:
-        return true
-      default:
-        return false
-    }
-  }
-}

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

@@ -1,116 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { abort, assign, draft, end, pick, issue } from '../../controllers/activity-instance'
-import { ActivityThread } from '../activity-thread/activity-thread'
-import { ActivityInstance, ActivityInstanceStatus } from './activity-instance'
-import { ActivityInstanceIssue, ActivityInstanceDraft } from './activity-instance-type'
-
-@Resolver(ActivityInstance)
-export class ActivityInstanceMutation {
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete Activity Instance of draft state' })
-  async deleteDraftActivityInstance(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    let draftActInst = await tx.getRepository(ActivityInstance).findOne({
-      where: { domain: { id: domain.id }, id, state : ActivityInstanceStatus.Draft }
-    })
-
-    if(draftActInst) {
-      await tx.getRepository(ActivityInstance).remove(draftActInst);
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple Activity Instances of draft state' })
-  async deleteDraftActivityInstances(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(ActivityInstance).delete({
-      domain: { id: domain.id },
-      id: In(ids),
-      state : ActivityInstanceStatus.Draft
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityInstance, { description: 'To draft standard ActivityInstance' })
-  async draftActivityInstance(
-    @Arg('activityInstance') activityInstance: ActivityInstanceDraft,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityInstance> {
-    return await draft(activityInstance, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityInstance, { description: 'To issue standard ActivityInstance' })
-  async issueActivityInstance(
-    @Arg('activityInstance') activityInstance: ActivityInstanceIssue,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityInstance> {
-    return await issue(activityInstance, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityThread!, {
-    nullable: true,
-    description:
-      'To pick an activity ActivityInstance voluntarily. [cautions] This resolver will return a assigned ActivityThread.'
-  })
-  async pickActivityInstance(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<ActivityThread> {
-    return await pick(id, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityInstance, { description: 'To assign a ActivityInstance' })
-  async assignActivityInstance(
-    @Arg('id') id: string,
-    @Arg('assignees', type => [String], { nullable: true, description: 'Email of assignee users' }) assignees: string[],
-    @Arg('reason', { nullable: true }) reason: string,
-    @Arg('dueAt', { nullable: true }) dueAt: Date,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityInstance> {
-    return await assign(
-      {
-        id,
-        assignees,
-        reason,
-        dueAt
-      },
-      context
-    )
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityInstance, { description: 'To end a ActivityInstance' })
-  async endActivityInstance(
-    @Arg('id') id: string,
-    @Arg('output', type => ScalarObject, { nullable: true }) output: { [key: string]: any },
-    @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityInstance> {
-    return await end({ id, output, reason }, context)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ActivityInstance, { description: 'To abort a ActivityInstance' })
-  async abortActivityInstance(
-    @Arg('id') id: string,
-    @Arg('reason', { nullable: true }) reason: string,
-    @Ctx() context: ResolverContext
-  ): Promise<ActivityInstance> {
-    return await abort({ id, reason }, context)
-  }
-}