@things-factory/sales-base 4.0.0-alpha.7 → 4.0.0-beta.1

package/server/service/return-order/return-order-types.ts

@@ -0,0 +1,196 @@
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Bizplace, BizplacePatch } from '@things-factory/biz-base'
+import { DomainPatch, Domain, ObjectRef } from '@things-factory/shell'
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { NewOrderInventory } from '../order-inventory/order-inventory-types'
+import { OrderVas } from '../order-vas/order-vas'
+import { NewOrderVas } from '../order-vas/order-vas-types'
+import { InventoryInfos } from '../release-good/release-good-types'
+import { ReturnOrder } from './return-order'
+
+@ObjectType()
+export class ReturnOrderList {
+  @Field(type => [ReturnOrder], { nullable: true })
+  items: ReturnOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@ObjectType()
+export class ReturnOrderDetail {
+  @Field(type => ID, { nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  etaDateTime: string
+
+  @Field({ nullable: true })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  crossDocking: boolean
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => [Attachment], { nullable: true })
+  attachment: Attachment[]
+
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @Field({ nullable: true })
+  updatedAt: string
+
+  @Field({ nullable: true })
+  createdAt: string
+
+  @Field(type => [InventoryInfos], { nullable: true })
+  inventoryInfos: InventoryInfos[]
+}
+
+@InputType()
+export class NewReturnOrder {
+  @Field(type => DomainPatch, { nullable: true })
+  domain: DomainPatch
+
+  @Field(type => BizplacePatch, { nullable: true })
+  bizplace: BizplacePatch
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field()
+  @Field({ nullable: false })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Field({ nullable: true })
+  jobSheetNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: NewOrderInventory[]
+
+  @Field(type => [NewOrderVas], { nullable: true })
+  orderVass: NewOrderVas[]
+
+  @Field({ nullable: true })
+  bizplaceName: string
+
+  @Field({ nullable: true })
+  customerBizplaceId: string
+
+  creator?: User
+
+  updater?: User
+}
+
+@InputType()
+export class ReturnOrderPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  bizplace: ObjectRef
+
+  @Field({ nullable: true })
+  ownTransport: boolean
+
+  @Field({ nullable: true })
+  eta: string
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  jobSheet: ObjectRef
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderInventories: ObjectRef[]
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVass: ObjectRef[]
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  status: string
+}

package/server/service/return-order/return-order.ts

@@ -0,0 +1,127 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { JobSheet, OrderInventory, OrderVas } from '../'
+
+@Entity()
+@Index('ix_return-order_0', (returnOrder: ReturnOrder) => [returnOrder.domain, returnOrder.name], { unique: true })
+@ObjectType()
+export class ReturnOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  ownTransport: boolean
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.returnOrder)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => OrderVas, orderVas => orderVas.returnOrder)
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  eta: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  truckNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  deliveryOrderNo: string
+
+  @OneToOne(type => JobSheet)
+  @JoinColumn()
+  @Field(type => JobSheet, { nullable: true })
+  jobSheet: JobSheet
+
+  @Column()
+  @Field()
+  status: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  acceptedBy: User
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.acceptedBy)
+  acceptedById: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  acceptedAt: Date
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((returnOrder: ReturnOrder) => returnOrder.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,6 @@
+import { ReverseKittingOrder } from './reverse-kitting-order'
+import { ReverseKittingOrderQuery } from './reverse-kitting-order-query'
+import { ReverseKittingOrderMutation } from './reverse-kitting-order-mutation'
+
+export const entities = [ReverseKittingOrder]
+export const resolvers = [ReverseKittingOrderQuery, ReverseKittingOrderMutation]

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

@@ -0,0 +1,374 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { Equal, In, Not } from 'typeorm'
+
+import { Bizplace, getCompanyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  Inventory,
+  InventoryPatch,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryNoGenerator,
+  InventoryUtil,
+  Location,
+  LOCATION_TYPE,
+  Warehouse
+} from '@things-factory/warehouse-base'
+
+import { ORDER_STATUS, ORDER_TYPES, ORDER_VAS_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils/order-no-generator'
+import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
+import { ReverseKittingOrder } from './reverse-kitting-order'
+import { NewReverseKittingOrder } from './reverse-kitting-order-type'
+
+@Resolver(ReverseKittingOrder)
+export class ReverseKittingOrderMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrder, { description: 'To create new ReverseKittingOrder' })
+  async generateReverseKittingOrder(
+    @Arg('reverseKittingOrder', type => NewReverseKittingOrder) reverseKittingOrder: NewReverseKittingOrder,
+    @Ctx() context: any
+  ): Promise<ReverseKittingOrder> {
+    const { tx, domain, user } = context.state
+
+    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+      where: { id: reverseKittingOrder.customerBizplaceId }
+    })
+
+    if (!customerBizplace) throw new Error('company is not found')
+
+    let reverseKittingOrderOIs = reverseKittingOrder.reverseKittingOrderInventories
+
+    // 1. Create reverse kitting order
+    const createdReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
+      ...reverseKittingOrder,
+      name: OrderNoGenerator.vasOrder(),
+      domain,
+      bizplace: customerBizplace,
+      status: ORDER_STATUS.PENDING,
+      creator: user
+    })
+
+    // 2. Create Reverse Kitting Order Items
+    reverseKittingOrderOIs = await Promise.all(
+      reverseKittingOrderOIs.map(async (ork: any) => {
+        if (ork?.inventory?.id) {
+          ork.inventory = await tx.getRepository(Inventory).findOne(ork.inventory.id)
+        }
+        return {
+          ...ork,
+          domain,
+          name: OrderNoGenerator.orderVas(),
+          reverseKittingOrder: createdReverseKittingOrder,
+          bizplace: customerBizplace,
+          type: ORDER_TYPES.VAS_ORDER,
+          status: ORDER_VAS_STATUS.PENDING,
+          creator: user,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOrderOIs)
+
+    return createdReverseKittingOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrder, { description: 'To execute reverse kitting order' })
+  async executingReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+    const { domain, user, tx } = context.state
+
+    const reverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: {
+        domain,
+        name,
+        status: ORDER_STATUS.EXECUTING,
+        bizplace: In(await getPermittedBizplaceIds(domain, user))
+      },
+      relations: [
+        'domain',
+        'bizplace',
+        'reverseKittingOrderInventories',
+        'reverseKittingOrderInventories.inventory',
+        'reverseKittingOrderInventories.inventory.product',
+        'reverseKittingOrderInventories.inventory.location',
+        'reverseKittingOrderInventories.inventory.warehouse',
+        'creator',
+        'updater'
+      ]
+    })
+
+    if (!reverseKittingOrder) throw new Error(`Reverse Kitting Order not exists`)
+
+    return reverseKittingOrder
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrder, { description: 'To confirm reverse kitting order' })
+  async confirmReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+    const { user, domain, tx } = context.state
+
+    const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: { domain, name, status: ORDER_STATUS.PENDING },
+      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
+    })
+
+    let foundORKs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+
+    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
+
+    // 1. Reverse Kitting Order Status change (PENDING => READY_TO_EXECUTE)
+    const reverseKitting: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
+      ...foundReverseKittingOrder,
+      status: ORDER_STATUS.READY_TO_EXECUTE,
+      updater: user
+    })
+
+    foundORKs = foundORKs.map((ork: ReverseKittingOrderInventory) => {
+      return { ...ork, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
+    })
+    await tx.getRepository(ReverseKittingOrderInventory).save(foundORKs)
+
+    return reverseKitting
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To confirm reverse kitting order' })
+  async completeReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain, user } = context.state
+
+    let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: { domain, name, status: ORDER_STATUS.EXECUTING },
+      relations: [
+        'bizplace',
+        'reverseKittingOrderInventories',
+        'reverseKittingOrderInventories.inventory',
+        'creator',
+        'updater'
+      ]
+    })
+
+    if (!foundReverseKittingOrder) throw new Error(foundReverseKittingOrder.name + ` not found`)
+
+    let reverseKittingOrderInventories: ReverseKittingOrderInventory[] =
+      foundReverseKittingOrder.reverseKittingOrderInventories
+
+    await Promise.all(
+      reverseKittingOrderInventories.map(async reverseKittingOI => {
+        let inventory: Inventory = reverseKittingOI.inventory
+        inventory.qty = inventory.qty - reverseKittingOI.qty
+        inventory.uomValue = inventory.uomValue - reverseKittingOI.uomValue
+
+        await InventoryUtil.transactionInventory(
+          inventory,
+          foundReverseKittingOrder,
+          -reverseKittingOI.qty,
+          -reverseKittingOI.uomValue,
+          INVENTORY_TRANSACTION_TYPE.REVERSE_KITTING,
+          user,
+          tx
+        )
+      })
+    )
+
+    reverseKittingOrderInventories = reverseKittingOrderInventories.map(reverseKittingOI => {
+      return {
+        ...reverseKittingOI,
+        status: ORDER_VAS_STATUS.TERMINATED,
+        updater: user
+      }
+    })
+
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOrderInventories)
+
+    foundReverseKittingOrder.status = ORDER_STATUS.DONE
+    foundReverseKittingOrder.updater = user
+
+    await tx.getRepository(ReverseKittingOrder).save(foundReverseKittingOrder)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrder, { description: 'To cancel reverse kitting order' })
+  async cancelReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+    const { user, domain, tx } = context.state
+
+    const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
+      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
+    })
+
+    let foundKOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+
+    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
+
+    const reverseKitting: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
+      ...foundReverseKittingOrder,
+      status: ORDER_STATUS.CANCELLED,
+      updater: user
+    })
+
+    foundKOIs = foundKOIs.map((ork: ReverseKittingOrderInventory) => {
+      return { ...ork, status: ORDER_VAS_STATUS.CANCELLED }
+    })
+    await tx.getRepository(ReverseKittingOrderInventory).save(foundKOIs)
+
+    return reverseKitting
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrder, { description: 'To activate reverse kitting order' })
+  async activateReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+    const { user, domain, tx } = context.state
+
+    const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
+      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
+    })
+
+    let foundKOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+
+    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
+
+    // 1. Reverse Kitting Order Status change (PENDING => PENDING_RECEIVE)
+    const reverseKitting: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).save({
+      ...foundReverseKittingOrder,
+      status: ORDER_STATUS.EXECUTING,
+      updater: user
+    })
+
+    foundKOIs = foundKOIs.map((ork: ReverseKittingOrderInventory) => {
+      return { ...ork, status: ORDER_VAS_STATUS.PROCESSING }
+    })
+    await tx.getRepository(ReverseKittingOrderInventory).save(foundKOIs)
+
+    return reverseKitting
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To execute reverse kitting order' })
+  async executeReverseKitting(
+    @Arg('name') name: string,
+    @Arg('inventory', type => InventoryPatch) inventory: Partial<Inventory>,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { user, domain, tx } = context.state
+
+    let reverseKittingOI: ReverseKittingOrderInventory = await tx.getRepository(ReverseKittingOrderInventory).findOne({
+      where: {
+        name,
+        domain,
+        status: Not(Equal(ORDER_VAS_STATUS.READY_TO_PROCESS))
+      },
+      relations: ['bizplace', 'reverseKittingOrder', 'reverseKittingOrder.bizplace', 'inventory']
+    })
+
+    const foundReverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
+    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
+
+    const customerBizplace: Bizplace = foundReverseKittingOrder.bizplace
+    const customerCompanyBizplace: Bizplace = await getCompanyBizplace(null, null, customerBizplace.id)
+
+    const productDetail: ProductDetail = await tx.getRepository(ProductDetail).findOne({
+      where: {
+        domain: customerCompanyBizplace.domain,
+        id: inventory.productDetailId
+      },
+      relations: ['product']
+    })
+
+    const location: Location = await tx.getRepository(Location).findOne({
+      where: {
+        domain,
+        name: inventory.locationName,
+        type: In([LOCATION_TYPE.SHELF, LOCATION_TYPE.BUFFER, LOCATION_TYPE.FLOOR])
+      },
+      relations: ['warehouse']
+    })
+    if (!location) throw new Error(inventory.locationName + ' not exists')
+
+    const palletId: string = inventory.palletId
+    await InventoryUtil.checkPalletDuplication(inventory.palletId, domain, tx)
+
+    const product: Product = productDetail.product
+    const packingType: string = productDetail.packingType
+    const packingSize: number = productDetail.packingSize
+    const uom: string = productDetail.uom
+    const qty: number = inventory.qty
+    const uomValue: number = Math.round(qty * productDetail.uomValue * 100) / 100
+    const batchId: string = reverseKittingOI.inventory.batchId
+    const orderId: string = foundReverseKittingOrder.id
+    const warehouse: Warehouse = location.warehouse
+    const zone: string = location.zone
+
+    let newInventory: Partial<Inventory> = new Inventory()
+    newInventory.bizplace = customerBizplace
+    newInventory.name = InventoryNoGenerator.inventoryName()
+    newInventory.orderVasId = reverseKittingOI.id
+    newInventory.palletId = palletId
+    newInventory.batchId = batchId
+    newInventory.product = product
+    newInventory.packingType = packingType
+    newInventory.packingSize = packingSize
+    newInventory.uom = uom
+    newInventory.qty = qty
+    newInventory.uomValue = uomValue
+    newInventory.refOrderId = orderId
+    newInventory.warehouse = warehouse
+    newInventory.location = location
+    newInventory.zone = zone
+    newInventory.status = INVENTORY_STATUS.STORED
+    newInventory.domain = domain
+    newInventory.creator = user
+    newInventory.updater = user
+
+    newInventory = await InventoryUtil.transactionInventory(
+      newInventory,
+      foundReverseKittingOrder,
+      newInventory.qty,
+      newInventory.uomValue,
+      INVENTORY_TRANSACTION_TYPE.REVERSE_KITTING,
+      user,
+      tx
+    )
+
+    let operationGuide: any = JSON.parse(reverseKittingOI.operationGuide)
+    let productCombinationSets: any[] = operationGuide.data.productCombinationSets
+    operationGuide.data.productCombinationSets = productCombinationSets.map(item => {
+      if (item.productDetailId == inventory.productDetailId) {
+        item.actualQty++
+      }
+      return item
+    })
+    reverseKittingOI.operationGuide = JSON.stringify(operationGuide)
+
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOI)
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ReverseKittingOrder' })
+  async deleteReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+    let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: { domain, name },
+      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
+    })
+
+    if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
+
+    const reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+
+    // 1. delete order reverse kittings
+    const productIds = reverseKittingOIs.map((ork: ReverseKittingOrderInventory) => ork.id)
+    if (productIds.length) {
+      await tx.getRepository(ReverseKittingOrderInventory).delete({ id: In(productIds) })
+    }
+
+    // 2. delete Reverse Kitting Order
+    await tx.getRepository(ReverseKittingOrder).delete({ domain, name })
+
+    return true
+  }
+}