@things-factory/worklist-client 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,134 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { Activity, ActivityType, ActivityUIType } from './activity'
+import { ActivityModelItem } from './activity-model-type'
+
+@InputType()
+export class NewActivity {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  activityType?: ActivityType
+
+  @Field(type => ScalarObject, { nullable: true })
+  model?: ActivityModelItem[]
+
+  @Field({ nullable: true })
+  priority?: number
+
+  @Field({ nullable: true })
+  startable?: boolean
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  standardTime?: number
+
+  @Field(type => ObjectRef, { nullable: true })
+  issuerRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  assigneeRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field({ nullable: true })
+  uiType?: ActivityUIType
+
+  @Field({ nullable: true })
+  uiSource?: string
+
+  @Field({ nullable: true })
+  viewType?: ActivityUIType
+
+  @Field({ nullable: true })
+  viewSource?: string
+
+  @Field({ nullable: true })
+  reportType?: ActivityUIType
+
+  @Field({ nullable: true })
+  reportSource?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+}
+
+@InputType()
+export class ActivityPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  activityType?: ActivityType
+
+  @Field(type => ScalarObject, { nullable: true })
+  model?: ActivityModelItem[]
+
+  @Field({ nullable: true })
+  priority?: number
+
+  @Field({ nullable: true })
+  startable?: boolean
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  standardTime?: number
+
+  @Field(type => ObjectRef, { nullable: true })
+  issuerRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  assigneeRole?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  supervisoryRole?: ObjectRef
+
+  @Field({ nullable: true })
+  uiType?: ActivityUIType
+
+  @Field({ nullable: true })
+  uiSource?: string
+
+  @Field({ nullable: true })
+  reportType?: ActivityUIType
+
+  @Field({ nullable: true })
+  reportSource?: string
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class ActivityList {
+  @Field(type => [Activity])
+  items: Activity[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/activity/activity.ts

@@ -0,0 +1,133 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+
+import { Role, User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ActivityModelItem } from './activity-model-type'
+
+export enum ActivityStatus {
+  Draft = 'draft',
+  Released = 'released',
+  Deprecated = 'deprecated'
+}
+
+registerEnumType(ActivityStatus, {
+  name: 'ActivityStatus',
+  description: 'state enumeration of a activity'
+})
+
+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'
+})
+
+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({ description: 'Entity for Activity' })
+export class Activity {
+  @Field(type => ID)
+  readonly id: string
+
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @Field(type => Domain, { nullable: true })
+  domain?: Domain
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  activityType?: ActivityType
+
+  @Field({ nullable: true })
+  state?: ActivityStatus
+
+  @Field(type => [ActivityModelItem], { nullable: true })
+  model?: ActivityModelItem[]
+
+  @Field({ nullable: true })
+  priority?: number = 1
+
+  @Field({ nullable: true })
+  startable?: boolean
+
+  @Field({ nullable: true })
+  schedule?: string
+
+  @Field({ nullable: true })
+  standardTime?: number
+
+  @Field(type => Role, { nullable: true })
+  issuerRole?: Role
+
+  @Field(type => Role, { nullable: true })
+  assigneeRole?: Role
+
+  @Field(type => Role, { nullable: true })
+  supervisoryRole?: Role
+
+  @Field({ nullable: true })
+  uiType?: ActivityUIType
+
+  @Field({ nullable: true })
+  uiSource?: string
+
+  @Field({ nullable: true })
+  viewType?: ActivityUIType
+
+  @Field({ nullable: true })
+  viewSource?: string
+
+  @Field({ nullable: true })
+  reportType?: ActivityUIType
+
+  @Field({ nullable: true })
+  reportSource?: string
+
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Field(type => User, { nullable: true, description: 'User assigned to the client application' })
+  client?: User
+
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+}

package/server/service/activity/index.ts

@@ -0,0 +1,6 @@
+import { Activity } from './activity'
+import { ActivityQuery } from './activity-query'
+
+export const entities = [Activity]
+export const resolvers = [ActivityQuery]
+export const subscribers = []

package/server/service/index.ts

@@ -0,0 +1,36 @@
+/* EXPORT ENTITY TYPES */
+export * from './activity/activity'
+export * from './work-center/work-center'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import {
+  entities as ActivityEntities,
+  resolvers as ActivityResolvers,
+  subscribers as ActivitySubscribers
+} from './activity'
+
+import {
+  entities as WorkCenterEntities,
+  resolvers as WorkCenterResolvers,
+  subscribers as WorkCenterSubscribers
+} from './work-center'
+
+export const entities = [
+  /* ENTITIES */
+  ...ActivityEntities,
+  ...WorkCenterEntities
+]
+
+export const subscribers = [
+  /* SUBSCRIBERS */
+  ...ActivitySubscribers,
+  ...WorkCenterSubscribers
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...ActivityResolvers,
+    ...WorkCenterResolvers
+  ]
+}

package/server/service/work-center/event-subscriber.ts

@@ -0,0 +1,17 @@
+import { EventSubscriber } from 'typeorm'
+
+import { HistoryEntitySubscriber } from '@operato/typeorm-history'
+
+import { WorkCenter } from './work-center'
+import { WorkCenterHistory } from './work-center-history'
+
+@EventSubscriber()
+export class WorkCenterHistoryEntitySubscriber extends HistoryEntitySubscriber<WorkCenter, WorkCenterHistory> {
+  public get entity() {
+    return WorkCenter
+  }
+
+  public get historyEntity() {
+    return WorkCenterHistory
+  }
+}

package/server/service/work-center/index.ts

@@ -0,0 +1,9 @@
+import { WorkCenter } from './work-center'
+import { WorkCenterHistory } from './work-center-history'
+import { WorkCenterQuery } from './work-center-query'
+import { WorkCenterMutation } from './work-center-mutation'
+import { WorkCenterHistoryEntitySubscriber } from './event-subscriber'
+
+export const entities = [WorkCenter, WorkCenterHistory]
+export const resolvers = [WorkCenterQuery, WorkCenterMutation]
+export const subscribers = [WorkCenterHistoryEntitySubscriber]

package/server/service/work-center/work-center-history.ts

@@ -0,0 +1,120 @@
+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 { WorkCenter, WorkCenterStatus } from './work-center'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+@Entity()
+@Index(
+  'ix_work-center_history_0',
+  (workCenterHistory: WorkCenterHistory) => [workCenterHistory.originalId, workCenterHistory.version],
+  { unique: true }
+)
+@Index(
+  'ix_work-center_history_1',
+  (workCenterHistory: WorkCenterHistory) => [
+    workCenterHistory.domain,
+    workCenterHistory.originalId,
+    workCenterHistory.version
+  ],
+  { unique: true }
+)
+@ObjectType({ description: 'History Entity of WorkCenter' })
+export class WorkCenterHistory implements HistoryEntityInterface<WorkCenter> {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column({ nullable: true, default: 1 })
+  @Field({ nullable: true })
+  version?: number = 1
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((workCenter: WorkCenter) => workCenter.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  state?: WorkCenterStatus
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  params?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deletedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((workCenter: WorkCenter) => workCenter.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((workCenter: WorkCenter) => workCenter.updater)
+  updaterId?: string
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+
+  @HistoryOriginalIdColumn()
+  public originalId!: string
+
+  @HistoryActionColumn({
+    nullable: false,
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+          ? 'varchar2'
+          : DATABASE_TYPE == 'mssql'
+            ? 'nvarchar'
+            : 'varchar',
+    enum:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? HistoryActionType
+        : undefined,
+    length: DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb' ? undefined : 10
+  })
+  public action!: HistoryActionType
+}

package/server/service/work-center/work-center-mutation.ts

@@ -0,0 +1,198 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { WorkCenter } from './work-center'
+import { NewWorkCenter, WorkCenterPatch } from './work-center-type'
+
+@Resolver(WorkCenter)
+export class WorkCenterMutation {
+  @Directive('@transaction')
+  @Mutation(returns => WorkCenter, { description: 'To create new WorkCenter' })
+  async createWorkCenter(@Arg('workCenter') workCenter: NewWorkCenter, @Ctx() context: ResolverContext): Promise<WorkCenter> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(WorkCenter).save({
+      ...workCenter,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    if (workCenter.thumbnail) {
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: workCenter.thumbnail,
+            refType: WorkCenter.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => WorkCenter, { description: 'To modify WorkCenter information' })
+  async updateWorkCenter(
+    @Arg('id') id: string,
+    @Arg('patch') patch: WorkCenterPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<WorkCenter> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(WorkCenter)
+    const workCenter = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...workCenter,
+      ...patch,
+      updater: user
+    })
+
+    if (patch.thumbnail) {
+      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: patch.thumbnail,
+            refType: WorkCenter.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [WorkCenter], { description: "To modify multiple WorkCenters' information" })
+  async updateMultipleWorkCenter(
+    @Arg('patches', type => [WorkCenterPatch]) patches: WorkCenterPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<WorkCenter[]> {
+    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 workCenterRepo = tx.getRepository(WorkCenter)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await workCenterRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        if (newRecord.thumbnail) {
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: newRecord.thumbnail,
+                refType: WorkCenter.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 workCenter = await workCenterRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await workCenterRepo.save({
+          ...workCenter,
+          ...updateRecord,
+          updater: user
+        })
+
+        if (updateRecord.thumbnail) {
+          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: updateRecord.thumbnail,
+                refType: WorkCenter.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete WorkCenter' })
+  async deleteWorkCenter(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(WorkCenter).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple WorkCenters' })
+  async deleteWorkCenters(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(WorkCenter).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple WorkCenters' })
+  async importWorkCenters(
+    @Arg('workCenters', type => [WorkCenterPatch]) workCenters: WorkCenterPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      workCenters.map(async (workCenter: WorkCenterPatch) => {
+        const createdWorkCenter: WorkCenter = await tx.getRepository(WorkCenter).save({ domain, ...workCenter })
+      })
+    )
+
+    return true
+  }
+}