@things-factory/process 6.0.57

package/server/controllers/process-instance/end.ts

@@ -0,0 +1,74 @@
+import { ProcessInstance, ProcessInstanceStatus } from '../../service/process-instance/process-instance'
+import { ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { evalProcessInstanceState } from '../common'
+
+export async function end(
+  { id, output, reason }: { id: string; output?: object; reason?: string },
+  context: ResolverContext
+): Promise<ProcessInstance> {
+  const { domain, user, tx } = context.state
+  const repository = tx.getRepository(ProcessInstance)
+
+  var processInstance = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: [
+      'domain',
+      'process',
+      'processThreads',
+      'assigneeRole',
+      'supervisoryRole',
+      'updater',
+      'creator',
+      'starter',
+      'terminator'
+    ]
+  })
+
+  if (!processInstance) {
+    throw new Error(
+      context.t('error.process-instance not found', {
+        processInstance: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a Task to Be End.
+    - The previous state of the task must not be End or Aborted.
+    - There should be no unfinished process threads.
+  */
+  if (processInstance.state == ProcessInstanceStatus.Aborted || processInstance.state == ProcessInstanceStatus.Ended) {
+    throw new Error(
+      context.t(`error.process-instance is already terminated`, {
+        id,
+        state: processInstance.state
+      })
+    )
+  }
+
+  const TERMINATED = [ProcessThreadStatus.Aborted, ProcessThreadStatus.Delegated, ProcessThreadStatus.Ended]
+
+  for (let processThread of processInstance.processThreads) {
+    if (TERMINATED.includes(processThread.state)) {
+      continue
+    }
+
+    throw new Error(
+      context.t(`error.all process threads should be terminated`, {
+        processThread: processThread.id,
+        state: processInstance.state
+      })
+    )
+  }
+
+  return await repository.save({
+    ...processInstance,
+    reason,
+    output,
+    transaction: 'end',
+    state: await evalProcessInstanceState(id, context),
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  } as any)
+}

package/server/controllers/process-instance/index.ts

@@ -0,0 +1,2 @@
+export * from './abort'
+export * from './end'

package/server/controllers/process-thread/_abort.ts

@@ -0,0 +1,20 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+
+export async function _abort(
+  { processThread, reason }: { processThread: ProcessThread; reason: string },
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ProcessThread)
+
+  return await repository.save({
+    ...processThread,
+    reason,
+    state: ProcessThreadStatus.Aborted,
+    transaction: 'abort',
+    updater: user,
+    terminatedAt: new Date(),
+    terminator: user
+  })
+}

package/server/controllers/process-thread/abort.ts

@@ -0,0 +1,48 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { updateProcessInstanceState } from '../common'
+import { _abort } from './_abort'
+
+export async function abort(
+  { id, reason }: { id: string; reason: string },
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  var repository = tx.getRepository(ProcessThread)
+
+  var processThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id },
+    relations: ['domain', 'processInstance', 'assignee', 'creator', 'updater']
+  })
+
+  if (!processThread) {
+    throw new Error(
+      context.t('error.process-thread not found', {
+        processThread: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a process thread to Be Aborted.
+    - The previous state of the process thread must not be End or Aborted.
+  */
+  if (
+    processThread.state == ProcessThreadStatus.Aborted ||
+    processThread.state == ProcessThreadStatus.Ended ||
+    processThread.state == ProcessThreadStatus.Delegated
+  ) {
+    throw new Error(
+      context.t(`error.process-thread is already terminated`, {
+        id,
+        state: processThread.state
+      })
+    )
+  }
+
+  const result = await _abort({ processThread, reason }, context)
+
+  await updateProcessInstanceState(processThread.processInstanceId, context)
+
+  return result
+}

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

@@ -0,0 +1,54 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { updateProcessInstanceState } from '../common'
+
+export async function end(
+  { id, output, reason }: { id: string; output?: object; reason?: string },
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  const repository = tx.getRepository(ProcessThread)
+
+  var processThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id }
+  })
+
+  if (!processThread) {
+    throw new Error(
+      context.t('error.process-thread not found', {
+        processThread: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a process thread to Be End.
+    - The previous state of the process thread must not be End or End.
+  */
+  if (
+    processThread.state == ProcessThreadStatus.Aborted ||
+    processThread.state == ProcessThreadStatus.Ended ||
+    processThread.state == ProcessThreadStatus.Delegated
+  ) {
+    throw new Error(
+      context.t(`error.process-thread is already terminated`, {
+        id,
+        actual: processThread.state
+      })
+    )
+  }
+
+  processThread = await repository.save({
+    ...processThread,
+    reason,
+    output,
+    transaction: 'end',
+    state: ProcessThreadStatus.Ended,
+    updater: user,
+    terminatedAt: new Date()
+  })
+
+  await updateProcessInstanceState(processThread.processInstanceId, context)
+
+  return processThread
+}

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

@@ -0,0 +1,3 @@
+export * from './abort'
+export * from './end'
+export * from './start'

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

@@ -0,0 +1,49 @@
+import { ProcessThread, ProcessThreadStatus } from '../../service/process-thread/process-thread'
+import { updateProcessInstanceState } from '../common'
+
+export async function start(
+  id: string,
+  output: object,
+  reason: string,
+  context: ResolverContext
+): Promise<ProcessThread> {
+  const { domain, user, tx } = context.state
+
+  const repository = tx.getRepository(ProcessThread)
+  const processThread = await repository.findOne({
+    where: { domain: { id: domain.id }, id }
+  })
+
+  if (!processThread) {
+    throw new Error(
+      context.t('error.process-thread not found', {
+        processThread: id
+      })
+    )
+  }
+
+  /* 
+    Prerequisites for a process thread to Be Started.
+    - The previous state of the process thread must not be terminated.
+  */
+  if (processThread.state !== ProcessThreadStatus.Assigned) {
+    throw new Error(
+      context.t(`error.process-thread should not be started`, {
+        id,
+        actual: processThread.state
+      })
+    )
+  }
+
+  const result = await tx.getRepository(ProcessThread).save({
+    ...processThread,
+    reason,
+    state: ProcessThreadStatus.Started,
+    transaction: 'start',
+    updater: user
+  })
+
+  await updateProcessInstanceState(processThread.processInstanceId, context)
+
+  return result
+}

package/server/index.ts

@@ -0,0 +1,4 @@
+export * from './migrations'
+export * from './middlewares'
+
+import './routes'

package/server/middlewares/index.ts

@@ -0,0 +1,3 @@
+export function initMiddlewares(app) {
+  /* can add middlewares into app */
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/routes.ts

@@ -0,0 +1,28 @@
+const debug = require('debug')('things-factory:process:routes')
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+})

package/server/service/index.ts

@@ -0,0 +1,32 @@
+/* EXPORT ENTITY TYPES */
+export * from './process-thread/process-thread'
+export * from './process-instance/process-instance'
+export * from './process/process'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as ProcessThreadEntities, resolvers as ProcessThreadResolvers, subscribers as ProcessThreadSubscribers } from './process-thread'
+import { entities as ProcessInstanceEntities, resolvers as ProcessInstanceResolvers, subscribers as ProcessInstanceSubscribers } from './process-instance'
+import { entities as ProcessEntities, resolvers as ProcessResolvers, subscribers as ProcessSubscribers } from './process'
+
+export const entities = [  
+  /* ENTITIES */
+	...ProcessThreadEntities,
+	...ProcessInstanceEntities,
+	...ProcessEntities,
+] 
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+	...ProcessThreadSubscribers,
+	...ProcessInstanceSubscribers,
+	...ProcessSubscribers,
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...ProcessThreadResolvers,
+		...ProcessInstanceResolvers,
+		...ProcessResolvers,
+  ] 
+}

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

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { Process } from './process'
+import { ProcessHistory } from './process-history'
+
+@EventSubscriber()
+export class ProcessHistoryEntitySubscriber extends HistoryEntitySubscriber<Process, ProcessHistory> {
+  public get entity() {
+    return Process
+  }
+
+  public get historyEntity() {
+    return ProcessHistory
+  }
+}

package/server/service/process/index.ts

@@ -0,0 +1,9 @@
+import { Process } from './process'
+import { ProcessHistory } from './process-history'
+import { ProcessMutation } from './process-mutation'
+import { ProcessQuery } from './process-query'
+import { ProcessHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [Process, ProcessHistory]
+export const resolvers = [ProcessQuery, ProcessMutation]
+export const subscribers = [ProcessHistoryEntitySubscriber]

package/server/service/process/process-history.ts

@@ -0,0 +1,102 @@
+import { Field, ID, 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 } from '@things-factory/shell'
+
+import { Process, ProcessStatus } from './process'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_process_history_0',
+  (processHistory: ProcessHistory) => [processHistory.originalId, processHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_process_history_1',
+  (processHistory: ProcessHistory) => [processHistory.domain, processHistory.originalId, processHistory.version],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of Process' })
+export class ProcessHistory implements HistoryEntityInterface<Process> {
+  @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((process: Process) => process.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: ProcessStatus
+
+  @ManyToOne(type => Role, { nullable: true })
+  @Field(type => Role, { nullable: true })
+  supervisoryRole?: Role
+
+  @RelationId((process: Process) => process.supervisoryRole)
+  supervisoryRoleId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Column()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((process: Process) => process.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((process: Process) => process.updater)
+  updaterId?: 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
+}

package/server/service/process/process-mutation.ts

@@ -0,0 +1,210 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+import { Application, CallbackBase, registerSchedule, unregisterSchedule } from '@things-factory/scheduler-client'
+
+import { Process } from './process'
+import { ProcessPatch, NewProcess } from './process-type'
+
+@Resolver(Process)
+export class ProcessMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Process, { description: 'To create new Process' })
+  async createProcess(@Arg('process') process: NewProcess, @Ctx() context: ResolverContext): Promise<Process> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(Process).save({
+      ...process,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    if (process.thumbnail) {
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: process.thumbnail,
+            refType: Process.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Process, { description: 'To modify Process information' })
+  async updateProcess(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ProcessPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Process> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Process)
+    const process = await repository.findOne({
+      where: { domain: { id: domain.id }, id },
+      /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
+      relations: ['domain', 'issuerRole', 'supervisoryRole', 'creator', 'updater']
+    })
+
+    const result = await repository.save({
+      ...process,
+      ...patch,
+      updater: user
+    })
+
+    if (patch.thumbnail) {
+      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: patch.thumbnail,
+            refType: Process.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => [Process], { description: "To modify multiple Processes' information" })
+  async updateMultipleProcess(
+    @Arg('patches', type => [ProcessPatch]) patches: ProcessPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Process[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const processRepo = tx.getRepository(Process)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await processRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        if (newRecord.thumbnail) {
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: newRecord.thumbnail,
+                refType: Process.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const process = await processRepo.findOne({
+          where: { id: updateRecord.id },
+          /* history에 항상 반영될 수 있도록 relations가 있어야 함. */
+          relations: ['domain', 'issuerRole', 'supervisoryRole', 'creator', 'updater']
+        })
+
+        const result = await processRepo.save({
+          ...process,
+          ...updateRecord,
+          updater: user
+        })
+
+        if (updateRecord.thumbnail) {
+          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: updateRecord.thumbnail,
+                refType: Process.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete Process' })
+  async deleteProcess(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Process).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Processes' })
+  async deleteProcesses(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Process).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "process", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To import multiple Processes' })
+  async importProcesses(
+    @Arg('processes', type => [ProcessPatch]) processes: ProcessPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      processes.map(async (process: ProcessPatch) => {
+        const createdProcess: Process = await tx.getRepository(Process).save({ domain, ...process })
+      })
+    )
+
+    return true
+  }
+}