@things-factory/routing-base 8.0.0-beta.9 → 8.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/routing-base",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.0",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "",
@@ -23,9 +23,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^8.0.0-beta.9",
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9"
+    "@things-factory/attachment-base": "^8.0.0",
+    "@things-factory/auth-base": "^8.0.0",
+    "@things-factory/shell": "^8.0.0"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "07ef27d272dd9a067a9648ac7013748510556a18"
 }

package/server/index.ts

@@ -0,0 +1 @@
+export * from './service'

package/server/service/index.ts

@@ -0,0 +1,43 @@
+import {
+  entities as OperationEntities,
+  resolvers as OperationResolvers
+} from './operation'
+import {
+  entities as RoutingEntities,
+  resolvers as RoutingResolvers
+} from './routing'
+import {
+  entities as RoutingItemEntities,
+  resolvers as RoutingItemResolvers
+} from './routing-item'
+
+/* EXPORT ENTITY TYPES */
+export * from './routing/routing'
+export * from './routing-item/routing-item'
+export * from './operation/operation'
+
+/* EXPORT TYPES */
+export * from './routing/routing-type'
+export * from './operation/operation-type'
+export * from './routing-item/routing-item-type'
+
+/* EXPORT MUTAIONS */
+export * from './routing/routing-mutation'
+export * from './operation/operation-mutation'
+export * from './routing-item/routing-item-mutation'
+
+/* EXPORT QUERIES */
+export * from './routing/routing-query'
+export * from './operation/operation-query'
+export * from './routing-item/routing-item-query'
+
+export const entities = [
+  /* ENTITIES */
+  ...RoutingEntities,
+  ...RoutingItemEntities,
+  ...OperationEntities
+]
+
+export const schema = {
+  resolverClasses: [...RoutingResolvers, ...RoutingItemResolvers, ...OperationResolvers]
+}

package/server/service/operation/index.ts

@@ -0,0 +1,9 @@
+import { Operation } from './operation'
+import { OperationMutation } from './operation-mutation'
+import { OperationQuery } from './operation-query'
+
+export const entities = [Operation]
+export const resolvers = [OperationQuery, OperationMutation]
+
+export * from './operation-query'
+export * from './operation-mutation'

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

@@ -0,0 +1,185 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { Operation } from './operation'
+import { NewOperation, OperationPatch } from './operation-type'
+
+@Resolver(Operation)
+export class OperationMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Operation, { description: 'To create new Operation' })
+  async createOperation(
+    @Arg('operation') operation: NewOperation,
+    @Ctx() context: ResolverContext
+  ): Promise<Operation> {
+    const { domain, user, tx } = context.state
+
+    const result = await tx.getRepository(Operation).save({
+      ...operation,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    if (operation.thumbnail) {
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: operation.thumbnail,
+            refType: Operation.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Operation, { description: 'To modify Operation information' })
+  async updateOperation(
+    @Arg('id') id: string,
+    @Arg('patch') patch: OperationPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Operation> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Operation)
+    const operation = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...operation,
+      ...patch,
+      updater: user
+    })
+
+    if (patch.thumbnail) {
+      // ?? { refBys: [operation.id] }
+      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+      await createAttachment(
+        null,
+        {
+          attachment: {
+            file: patch.thumbnail,
+            refType: Operation.name,
+            refBy: result.id
+          }
+        },
+        context
+      )
+    }
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Operation], { description: "To modify multiple Operations' information" })
+  async updateMultipleOperation(
+    @Arg('patches', type => [OperationPatch]) patches: OperationPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Operation[]> {
+    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 operationRepo = tx.getRepository(Operation)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await operationRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        if (newRecord.thumbnail) {
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: newRecord.thumbnail,
+                refType: Operation.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const operation = await operationRepo.findOneBy({ id: newRecord.id })
+
+        const result = await operationRepo.save({
+          ...operation,
+          ...newRecord,
+          updater: user
+        })
+
+        if (newRecord.thumbnail) {
+          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
+          await createAttachment(
+            null,
+            {
+              attachment: {
+                file: newRecord.thumbnail,
+                refType: Operation.name,
+                refBy: result.id
+              }
+            },
+            context
+          )
+        }
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Operation' })
+  async deleteOperation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Operation).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple operations' })
+  async deleteOperations(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Operation).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+}

package/server/service/operation/operation-query.ts

@@ -0,0 +1,66 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Operation } from './operation'
+import { OperationList } from './operation-type'
+
+@Resolver(Operation)
+export class OperationQuery {
+  @Query(returns => Operation, { description: 'To fetch a Operation' })
+  async operation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Operation> {
+    const { domain } = context.state
+
+    return await getRepository(Operation).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => OperationList, { description: 'To fetch multiple Operations' })
+  async operations(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<OperationList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(Operation),
+      params,
+      domain,
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() operation: Operation): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: operation.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() operation: Operation): Promise<User> {
+    return await getRepository(User).findOneBy({ id: operation.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() operation: Operation): Promise<User> {
+    return await getRepository(User).findOneBy({ id: operation.creatorId })
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() operation: Operation): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: operation.domainId },
+        refBy: operation.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+}

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

@@ -0,0 +1,68 @@
+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 { Operation } from './operation'
+
+@InputType()
+export class NewOperation {
+  @Field({ nullable: false })
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  operationStdChart?: string
+
+  @Field({ nullable: true })
+  operationStdTime?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+}
+
+@InputType()
+export class OperationPatch {
+  @Field(type => ID, { nullable: true })
+  id!: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  operationStdChart?: string
+
+  @Field({ nullable: true })
+  operationStdTime?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => GraphQLUpload, { nullable: true })
+  thumbnail?: FileUpload
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class OperationList {
+  @Field(type => [Operation])
+  items: Operation[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/operation/operation.ts

@@ -0,0 +1,109 @@
+import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+export enum OperationStatus {
+  STATUS_A = 'STATUS_A',
+  STATUS_B = 'STATUS_B',
+  ASSY = 'Assembly',
+  INV = 'Inventory',
+  PACK = 'Packing',
+  SMT = 'SMT',
+  STD = 'Standard',
+  TEST = 'Test'
+}
+
+registerEnumType(OperationStatus, {
+  name: 'OperationStatus',
+  description: 'state enumeration of a operation'
+})
+
+@Entity()
+@Index('ix_operation_0', (operation: Operation) => [operation.domain, operation.name], { unique: true })
+@ObjectType({ description: 'Entity for Operation' })
+export class Operation {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { nullable: false })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: false })
+  domain: Domain
+
+  @RelationId((operation: Operation) => operation.domain)
+  domainId: string
+
+  @Column()
+  @Field({ nullable: false })
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  operationStdChart?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  operationStdTime?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field(type => String, { nullable: true })
+  thumbnail?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((operation: Operation) => operation.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((operation: Operation) => operation.updater)
+  updaterId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+}

package/server/service/routing/index.ts

@@ -0,0 +1,9 @@
+import { Routing } from './routing'
+import { RoutingMutation } from './routing-mutation'
+import { RoutingQuery } from './routing-query'
+
+export const entities = [Routing]
+export const resolvers = [RoutingQuery, RoutingMutation]
+
+export * from './routing-query'
+export * from './routing-mutation'

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

@@ -0,0 +1,110 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Routing } from './routing'
+import { NewRouting, RoutingPatch } from './routing-type'
+
+@Resolver(Routing)
+export class RoutingMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Routing, { description: 'To create new Routing' })
+  async createRouting(@Arg('routing') routing: NewRouting, @Ctx() context: ResolverContext): Promise<Routing> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Routing).save({
+      ...routing,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Routing, { description: 'To modify Routing information' })
+  async updateRouting(
+    @Arg('id') id: string,
+    @Arg('patch') patch: RoutingPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Routing> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Routing)
+    const routing = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...routing,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Routing], { description: "To modify multiple Routings' information" })
+  async updateMultipleRouting(
+    @Arg('patches', type => [RoutingPatch]) patches: RoutingPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Routing[]> {
+    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 routingRepo = tx.getRepository(Routing)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await routingRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const routing = await routingRepo.findOneBy({ id: newRecord.id })
+
+        const result = await routingRepo.save({
+          ...routing,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Routing' })
+  async deleteRouting(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Routing).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple routings' })
+  async deleteRoutings(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Routing).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+}