@things-factory/routing-base 4.0.22

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

@@ -0,0 +1,211 @@
+import {
+  Arg,
+  Args,
+  Ctx,
+  FieldResolver,
+  Query,
+  Resolver,
+  Root
+} from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  convertListParams,
+  Domain,
+  ListParam
+} from '@things-factory/shell'
+
+import { Operation } from '../operation/operation'
+import { Routing } from './routing'
+import { RoutingList } from './routing-type'
+
+@Resolver(Routing)
+export class RoutingQuery {
+  @Query(returns => Routing, { description: 'To fetch a Routing' })
+  async routing(@Arg('id') id: string, @Ctx() context: any): Promise<Routing> {
+    const { domain } = context.state
+
+    return await getRepository(Routing).findOne({
+      where: { domain, name }
+    })
+  }
+
+  @Query(returns => RoutingList, { description: 'To fetch multiple Routings' })
+  async routings(@Args() params: ListParam, @Ctx() context: any): Promise<RoutingList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Routing).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() routing: Routing): Promise<Domain> {
+    return await getRepository(Domain).findOne(routing.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() routing: Routing): Promise<User> {
+    return await getRepository(User).findOne(routing.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() routing: Routing): Promise<User> {
+    return await getRepository(User).findOne(routing.creatorId)
+  }
+}
+
+export async function firstOperation(routingId: string, context: any): Promise<Operation> {
+  const operation = await getRepository(Operation).query(
+    `
+        select 
+          * 
+        from 
+          operations 
+        where 
+          id = 
+            (
+              select 
+                operation_id 
+              from 
+                routing_items 
+              where 
+                routing_id = '${routingId}' 
+              and 
+                rank = 
+                  (
+                    select 
+                      min(rank) 
+                    from 
+                      routing_items 
+                    where 
+                      routing_id = '${routingId}'
+                  )
+              )
+      `
+  )
+  return operation
+}
+
+export async function nextOperation(operationId: string, routingId: string, context: any): Promise<Operation> {
+  const operation = await getRepository(Operation).query(
+    `
+        select 
+          * 
+        from 
+          operations 
+        where 
+          id = 
+            (
+              select 
+                operation_id 
+              from 
+                routing_items 
+              where 
+                routing_id = '${routingId}' 
+              and 
+                rank = 
+                  (
+                    select 
+                      min(rank) 
+                    from 
+                      routing_items 
+                    where 
+                      routing_id = '${routingId}' 
+                    and 
+                      rank > 
+                        (
+                          select 
+                            rank 
+                          from 
+                            routing_items 
+                          where 
+                            routing_id = '${routingId}' 
+                          and 
+                            operation_id = '${operationId}'
+                        )
+                    )
+              )
+      `
+  )
+  return operation
+}
+
+export async function prevOperation(operationId: string, routingId: string, context: any): Promise<Operation> {
+  const operation = await getRepository(Operation).query(
+    `
+        select 
+          * 
+        from 
+          operations 
+        where 
+          id = 
+            (
+              select 
+                operation_id 
+              from 
+                routing_items 
+              where 
+                routing_id = '${routingId}' 
+              and 
+                rank = 
+                  (
+                    select 
+                      max(rank) 
+                    from 
+                      routing_items 
+                    where 
+                      routing_id = '${routingId}' 
+                    and 
+                      rank < 
+                        (
+                          select 
+                            rank 
+                          from 
+                            routing_items 
+                          where 
+                            routing_id = '${routingId}' 
+                          and 
+                            operation_id = '${operationId}'
+                        )
+                    )
+              )
+      `
+  )
+
+  return operation
+}
+
+export async function lastOperation(routingId: string, context: any): Promise<Operation> {
+  const operation = await getRepository(Operation).query(
+    `
+        select 
+          * 
+        from 
+          operations 
+        where 
+          id = 
+            (
+              select 
+                operation_id 
+              from 
+                routing_items 
+              where 
+                routing_id = '${routingId}' 
+              and 
+                rank = 
+                  (
+                    select 
+                      max(rank) 
+                    from 
+                      routing_items 
+                    where 
+                      routing_id = '${routingId}'
+                  )
+              )
+      `
+  )
+  return operation
+}

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

@@ -0,0 +1,48 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Routing } from './routing'
+
+@InputType()
+export class NewRouting {
+  @Field({ nullable: false })
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  createdLot?: boolean
+
+  @Field({ nullable: true })
+  active?: boolean
+}
+
+@InputType()
+export class RoutingPatch {
+  @Field(type => ID, { nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  createdLot?: boolean
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class RoutingList {
+  @Field(type => [Routing])
+  items: Routing[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/routing/routing.ts

@@ -0,0 +1,88 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  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'
+
+export enum RoutingStatus {
+  STATUS_A = 'STATUS_A',
+  STATUS_B = 'STATUS_B'
+}
+
+registerEnumType(RoutingStatus, {
+  name: 'RoutingStatus',
+  description: 'state enumeration of a routing'
+})
+
+@Entity()
+@Index('ix_routing_0', (routing: Routing) => [routing.domain, routing.name], { unique: true })
+@ObjectType({ description: 'Entity for Routing' })
+export class Routing {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { nullable: false })
+  readonly id: string
+
+  @ManyToOne(type => Domain, { nullable: false })
+  @Field({ nullable: false })
+  domain?: Domain
+
+  @RelationId((routing: Routing) => routing.domain)
+  domainId?: string
+
+  @Column({ nullable: false })
+  @Field({ nullable: false })
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  createdLot?: boolean
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((routing: Routing) => routing.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((routing: Routing) => routing.creator)
+  updaterId?: string
+}

package/server/service/routing-item/index.ts

@@ -0,0 +1,6 @@
+import { RoutingItem } from './routing-item'
+import { RoutingItemQuery } from './routing-item-query'
+import { RoutingItemMutation } from './routing-item-mutation'
+
+export const entities = [RoutingItem]
+export const resolvers = [RoutingItemQuery, RoutingItemMutation]

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

@@ -0,0 +1,119 @@
+import {
+  Arg,
+  Ctx,
+  Directive,
+  Mutation,
+  Resolver
+} from 'type-graphql'
+import { In } from 'typeorm'
+
+import { RoutingItem } from './routing-item'
+import {
+  NewRoutingItem,
+  RoutingItemPatch
+} from './routing-item-type'
+
+@Resolver(RoutingItem)
+export class RoutingItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => RoutingItem, { description: 'To create new RoutingItem' })
+  async createRoutingItem(@Arg('routingItem') routingItem: NewRoutingItem, @Ctx() context: any): Promise<RoutingItem> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(RoutingItem).save({
+      ...routingItem,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => RoutingItem, { description: 'To modify RoutingItem information' })
+  async updateRoutingItem(
+    @Arg('id') id: string,
+    @Arg('patch') patch: RoutingItemPatch,
+    @Ctx() context: any
+  ): Promise<RoutingItem> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(RoutingItem)
+    const routingItem = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...routingItem,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [RoutingItem], { description: "To modify multiple RoutingItems' information" })
+  async updateMultipleRoutingItem(
+    @Arg('patches', type => [RoutingItemPatch]) patches: RoutingItemPatch[],
+    @Ctx() context: any
+  ): Promise<RoutingItem[]> {
+    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 routingItemRepo = tx.getRepository(RoutingItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await routingItemRepo.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 routingItem = await routingItemRepo.findOne(newRecord.id)
+
+        const result = await routingItemRepo.save({
+          ...routingItem,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete RoutingItem' })
+  async deleteRoutingItem(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(RoutingItem).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple routingItems' })
+  async deleteRoutingItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(RoutingItem).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/routing-item/routing-item-query.ts

@@ -0,0 +1,61 @@
+import {
+  Arg,
+  Args,
+  Ctx,
+  FieldResolver,
+  Query,
+  Resolver,
+  Root
+} from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  convertListParams,
+  Domain,
+  ListParam
+} from '@things-factory/shell'
+
+import { RoutingItem } from './routing-item'
+import { RoutingItemList } from './routing-item-type'
+
+@Resolver(RoutingItem)
+export class RoutingItemQuery {
+  @Query(returns => RoutingItem, { description: 'To fetch a RoutingItem' })
+  async routingItem(@Arg('routing') routing: string, @Ctx() context: any): Promise<RoutingItem> {
+    const { domain } = context.state
+
+    return await getRepository(RoutingItem).findOne({
+      relations: ['routing'],
+      where: { domain, routing }
+    })
+  }
+
+  @Query(returns => RoutingItemList, { description: 'To fetch multiple RoutingItems' })
+  async routingItems(@Args() params: ListParam, @Ctx() context: any): Promise<RoutingItemList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(RoutingItem).findAndCount({
+      ...convertedParams,
+      relations: ['routing', 'operation']
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() routingItem: RoutingItem): Promise<Domain> {
+    return await getRepository(Domain).findOne(routingItem.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() routingItem: RoutingItem): Promise<User> {
+    return await getRepository(User).findOne(routingItem.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() routingItem: RoutingItem): Promise<User> {
+    return await getRepository(User).findOne(routingItem.creatorId)
+  }
+}

package/server/service/routing-item/routing-item-type.ts

@@ -0,0 +1,67 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+
+import { RoutingItem } from './routing-item'
+
+@InputType()
+export class NewRoutingItem {
+  @Field(type => ObjectRef, { nullable: true })
+  routing: ObjectRef
+
+  @Field({ nullable: true })
+  rank: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  operation: ObjectRef
+
+  @Field({ nullable: true })
+  startedTransaction?: string
+
+  @Field({ nullable: true })
+  isStock?: boolean
+
+  @Field({ nullable: true })
+  operatorViewId?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+}
+
+@InputType()
+export class RoutingItemPatch {
+  @Field(type => ID, { nullable: true })
+  id: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  routing: ObjectRef
+
+  @Field({ nullable: true })
+  rank: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  operation?: ObjectRef
+
+  @Field({ nullable: true })
+  startedTransaction?: string
+
+  @Field({ nullable: true })
+  isStock?: boolean
+
+  @Field({ nullable: true })
+  operatorViewId?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class RoutingItemList {
+  @Field(type => [RoutingItem])
+  items: RoutingItem[]
+
+  @Field(type => Int)
+  total: number
+}