@things-factory/sales-base 4.0.0-alpha.6 → 4.0.0-beta.0

package/server/service/reverse-kitting-order/reverse-kitting-order-query.ts

@@ -0,0 +1,111 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
+
+import { ORDER_VAS_STATUS } from '../../constants'
+import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
+import { ReverseKittingOrder } from './reverse-kitting-order'
+import { ReverseKittingOrderList } from './reverse-kitting-order-type'
+
+@Resolver(ReverseKittingOrder)
+export class ReverseKittingOrderQuery {
+  @Query(returns => ReverseKittingOrder, { description: 'To fetch a ReverseKittingOrder' })
+  async reverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    return await getRepository(ReverseKittingOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'orderReverseKittings',
+        'orderReverseKittings.vas',
+        'orderReverseKittings.inventory',
+        'orderReverseKittings.inventory.product',
+        'orderReverseKittings.inventory.location',
+        'orderReverseKittings.inventory.warehouse',
+        'orderReverseKittings.targetProduct',
+        'creator',
+        'updater'
+      ]
+    })
+  }
+
+  @Query(returns => ReverseKittingOrder, { description: 'To fetch a ReverseKittingOrder' })
+  async reverseKittingInventories(
+    @Arg('orderReverseKittingName') orderReverseKittingName: string,
+    @Ctx() context: any
+  ): Promise<Inventory[]> {
+    const { domain } = context.state
+    const foundOrderReverseKitting: ReverseKittingOrderInventory = await getRepository(
+      ReverseKittingOrderInventory
+    ).findOne({
+      where: {
+        domain,
+        name: orderReverseKittingName,
+        status: ORDER_VAS_STATUS.PROCESSING
+      },
+      relations: ['bizplace', 'reverseKittingOrder', 'inventory']
+    })
+
+    if (!foundOrderReverseKitting) return
+
+    const reverseKittingOrder: ReverseKittingOrder = foundOrderReverseKitting.reverseKittingOrder
+    const customerBizplace: Bizplace = foundOrderReverseKitting.bizplace
+    return await getRepository(Inventory).find({
+      where: {
+        domain,
+        bizplace: customerBizplace,
+        refOrderId: reverseKittingOrder.id,
+        orderVasId: foundOrderReverseKitting.id,
+        status: INVENTORY_STATUS.STORED
+      },
+      relations: ['product', 'bizplace']
+    })
+  }
+
+  @Query(returns => ReverseKittingOrderList, { description: 'To fetch multiple ReverseKittingOrders' })
+  async reverseKittingOrders(@Args() params: ListParam, @Ctx() context: any): Promise<ReverseKittingOrderList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const convertedParams = convertListParams(params)
+    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
+
+    const [items, total] = await getRepository(ReverseKittingOrder).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'bizplace',
+        'orderReverseKittings',
+        'orderReverseKittings.inventory',
+        'orderReverseKittings.inventory.product',
+        'creator',
+        'updater'
+      ]
+    })
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<Domain> {
+    return await getRepository(Domain).findOne(reverseKittingOrder.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<User> {
+    return await getRepository(User).findOne(reverseKittingOrder.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<User> {
+    return await getRepository(User).findOne(reverseKittingOrder.creatorId)
+  }
+}

package/server/service/reverse-kitting-order/reverse-kitting-order-type.ts

@@ -0,0 +1,54 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { NewReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory-type'
+import { ReverseKittingOrder } from './reverse-kitting-order'
+
+@InputType()
+export class NewReverseKittingOrder {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  customerBizplaceId?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field(type => [NewReverseKittingOrderInventory], { nullable: true })
+  reverseKittingOrderInventories?: NewReverseKittingOrderInventory[]
+
+  @Field({ nullable: true })
+  remark?: string
+}
+
+@InputType()
+export class ReverseKittingOrderPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  reverseKittingOrderInventories: ObjectRef[]
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class ReverseKittingOrderList {
+  @Field(type => [ReverseKittingOrder])
+  items: ReverseKittingOrder[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/reverse-kitting-order/reverse-kitting-order.ts

@@ -0,0 +1,85 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
+
+@Entity()
+@Index(
+  'ix_reverse_kitting_order_0',
+  (reverseKittingOrder: ReverseKittingOrder) => [reverseKittingOrder.domain, reverseKittingOrder.name],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ReverseKittingOrder' })
+export class ReverseKittingOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.domain)
+  domainId?: string
+
+  @ManyToOne(type => Bizplace)
+  bizplace: Bizplace
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.bizplace)
+  bizplaceId?: string
+
+  @OneToMany(
+    type => ReverseKittingOrderInventory,
+    reverseKittingOrderInventory => reverseKittingOrderInventory.reverseKittingOrder
+  )
+  @Field(type => [ReverseKittingOrderInventory], { nullable: true })
+  reverseKittingOrderInventories?: ReverseKittingOrderInventory[]
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.creator)
+  updaterId?: string
+}

package/server/service/reverse-kitting-order-inventory/index.ts

@@ -0,0 +1,6 @@
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+import { ReverseKittingOrderInventoryQuery } from './reverse-kitting-order-inventory-query'
+import { ReverseKittingOrderInventoryMutation } from './reverse-kitting-order-inventory-mutation'
+
+export const entities = [ReverseKittingOrderInventory]
+export const resolvers = [ReverseKittingOrderInventoryQuery, ReverseKittingOrderInventoryMutation]

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-mutation.ts

@@ -0,0 +1,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+import { NewReverseKittingOrderInventory, ReverseKittingOrderInventoryPatch } from './reverse-kitting-order-inventory-type'
+
+@Resolver(ReverseKittingOrderInventory)
+export class ReverseKittingOrderInventoryMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrderInventory, { description: 'To create new ReverseKittingOrderInventory' })
+  async createReverseKittingOrderInventory(@Arg('reverseKittingOrderInventory') reverseKittingOrderInventory: NewReverseKittingOrderInventory, @Ctx() context: any): Promise<ReverseKittingOrderInventory> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ReverseKittingOrderInventory).save({
+      ...reverseKittingOrderInventory,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrderInventory, { description: 'To modify ReverseKittingOrderInventory information' })
+  async updateReverseKittingOrderInventory(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ReverseKittingOrderInventoryPatch,
+    @Ctx() context: any
+  ): Promise<ReverseKittingOrderInventory> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(ReverseKittingOrderInventory)
+    const reverseKittingOrderInventory = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...reverseKittingOrderInventory,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ReverseKittingOrderInventory], { description: "To modify multiple ReverseKittingOrderInventories' information" })
+  async updateMultipleReverseKittingOrderInventory(
+    @Arg('patches', type => [ReverseKittingOrderInventoryPatch]) patches: ReverseKittingOrderInventoryPatch[],
+    @Ctx() context: any
+  ): Promise<ReverseKittingOrderInventory[]> {
+    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 reverseKittingOrderInventoryRepo = tx.getRepository(ReverseKittingOrderInventory)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await reverseKittingOrderInventoryRepo.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 reverseKittingOrderInventory = await reverseKittingOrderInventoryRepo.findOne(newRecord.id)
+
+        const result = await reverseKittingOrderInventoryRepo.save({
+          ...reverseKittingOrderInventory,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ReverseKittingOrderInventory' })
+  async deleteReverseKittingOrderInventory(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ReverseKittingOrderInventory).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple reverseKittingOrderInventorys' })
+  async deleteReverseKittingOrderInventories(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ReverseKittingOrderInventory).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-query.ts

@@ -0,0 +1,43 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+import { ReverseKittingOrderInventoryList } from './reverse-kitting-order-inventory-type'
+
+@Resolver(ReverseKittingOrderInventory)
+export class ReverseKittingOrderInventoryQuery {
+  @Query(returns => ReverseKittingOrderInventory, { description: 'To fetch a ReverseKittingOrderInventory' })
+  async reverseKittingOrderInventory(@Arg('id') id: string, @Ctx() context: any): Promise<ReverseKittingOrderInventory> {
+    const { domain } = context.state
+
+    return await getRepository(ReverseKittingOrderInventory).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => ReverseKittingOrderInventoryList, { description: 'To fetch multiple ReverseKittingOrderInventories' })
+  async reverseKittingOrderInventories(@Args() params: ListParam, @Ctx() context: any): Promise<ReverseKittingOrderInventoryList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(ReverseKittingOrderInventory).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<Domain> {
+    return await getRepository(Domain).findOne(reverseKittingOrderInventory.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<User> {
+    return await getRepository(User).findOne(reverseKittingOrderInventory.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<User> {
+    return await getRepository(User).findOne(reverseKittingOrderInventory.creatorId)
+  }
+}

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-type.ts

@@ -0,0 +1,86 @@
+import { Field, Float, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+
+@InputType()
+export class NewReverseKittingOrderInventory {
+  @Field()
+  name: string
+
+  @Field(type => Int)
+  set: number
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field({ nullable: true })
+  operationGuide?: string
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field(type => ObjectRef)
+  reverseKittingOrder?: ObjectRef
+
+  @Field(type => ObjectRef)
+  inventory?: ObjectRef
+
+  @Field({ nullable: true })
+  status: string
+}
+
+@InputType()
+export class ReverseKittingOrderInventoryPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field()
+  name: string
+
+  @Field(type => Int)
+  set: number
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field({ nullable: true })
+  operationGuide?: string
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field(type => ObjectRef)
+  reverseKittingOrder: ObjectRef
+
+  @Field(type => ObjectRef)
+  inventory: ObjectRef
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class ReverseKittingOrderInventoryList {
+  @Field(type => [ReverseKittingOrderInventory])
+  items: ReverseKittingOrderInventory[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory.ts

@@ -0,0 +1,117 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { ReverseKittingOrder } from '../reverse-kitting-order/reverse-kitting-order'
+
+@Entity()
+@Index(
+  'ix_reverse_kitting_order_inventory_0',
+  (reverseKittingOrderInventory: ReverseKittingOrderInventory) => [
+    reverseKittingOrderInventory.domain,
+    reverseKittingOrderInventory.name
+  ],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ReverseKittingOrderInventory' })
+export class ReverseKittingOrderInventory {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.domain)
+  domainId?: string
+
+  @ManyToOne(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.bizplace)
+  bizplaceId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  set?: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  qty?: number
+
+  @Column('float', { nullable: true })
+  @Field({ nullable: true })
+  uomValue?: number
+
+  @ManyToOne(type => ReverseKittingOrder)
+  @Field(type => ReverseKittingOrder)
+  reverseKittingOrder: ReverseKittingOrder
+
+  @RelationId(
+    (reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.reverseKittingOrder
+  )
+  reverseKittingOrderId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  operationGuide?: string
+
+  @ManyToOne(type => Inventory)
+  @Field(type => Inventory)
+  inventory?: Inventory
+
+  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.inventory)
+  inventoryId?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark?: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.creator)
+  updaterId?: string
+}

package/server/service/shipping-order/index.ts

@@ -0,0 +1,6 @@
+import { ShippingOrder } from './shipping-order'
+import { ShippingOrderMutation } from './shipping-order-mutation'
+import { ShippingOrderQuery } from './shipping-order-query'
+
+export const entities = [ShippingOrder]
+export const resolvers = [ShippingOrderQuery, ShippingOrderMutation]

package/server/service/shipping-order/shipping-order-mutation.ts

@@ -0,0 +1,61 @@
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+import uuid from 'uuid/v4'
+import { NewShippingOrder, ShippingOrderPatch } from '../'
+import { ShippingOrder } from './shipping-order'
+
+@Resolver(ShippingOrder)
+export class ShippingOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ShippingOrder)
+  async createShippingOrder(
+    @Arg('shippingOrder', type => NewShippingOrder) shippingOrder: NewShippingOrder,
+    @Ctx() context: any
+  ): Promise<ShippingOrder> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(ShippingOrder)
+    const newShippingOrder = {
+      id: uuid(),
+      ...shippingOrder
+    }
+
+    return await repository.save(newShippingOrder)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ShippingOrder)
+  async updateShippingOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => ShippingOrderPatch) patch: ShippingOrderPatch,
+    @Ctx() context: any
+  ): Promise<ShippingOrder> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const shippingOrder = await tx.getRepository(ShippingOrder).findOne({
+      where: {
+        domain,
+        name,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      }
+    })
+
+    return await tx.getRepository(ShippingOrder).save({
+      ...shippingOrder,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteShippingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(ShippingOrder).delete({ domain, name })
+    return true
+  }
+}