@things-factory/sales-base 3.6.46 → 3.6.50

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

@@ -0,0 +1,68 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { OrderReverseKitting } from './order-reverse-kitting'
+
+@Entity()
+@Index(
+  'ix_reverse-kitting-order_0',
+  (reverseKittingOrder: ReverseKittingOrder) => [reverseKittingOrder.domain, reverseKittingOrder.name],
+  { unique: true }
+)
+export class ReverseKittingOrder {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @ManyToOne(type => Bizplace)
+  bizplace: Bizplace
+
+  @Column()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  description: string
+
+  @OneToMany(type => OrderReverseKitting, orderReverseKitting => orderReverseKitting.reverseKittingOrder)
+  orderReverseKittings: OrderReverseKitting[]
+
+  @Column({
+    nullable: true
+  })
+  remark: String
+
+  @Column()
+  status: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/graphql/resolvers/index.ts

@@ -1,26 +1,27 @@
 import * as ArrivalNotice from './arrival-notice'
+import * as Claim from './claim'
+import * as ClaimDetail from './claim-detail'
+import * as ClaimOrder from './claim-order'
 import * as CollectionOrder from './collection-order'
 import * as DeliveryOrder from './delivery-order'
-import * as Invoice from './invoice'
+import * as GoodsReceivalNote from './goods-receival-note'
 import * as InventoryCheck from './inventory-check'
+import * as Invoice from './invoice'
 import * as JobSheet from './job-sheet'
-import * as OrderProduct from './order-product'
 import * as OrderInventory from './order-inventory'
+import * as OrderProduct from './order-product'
 import * as OrderVas from './order-vas'
+import * as Others from './others'
 import * as PurchaseOrder from './purchase-order'
 import * as PurchaseOrderOtherCharge from './purchase-order-other-charge'
-import * as ShippingOrder from './shipping-order'
 import * as ReleaseGood from './release-good'
-import * as ReturnOrder from './return-order'
 import * as RetailReplenishmentOrder from './retail-replenishment-order'
+import * as ReturnOrder from './return-order'
+import * as ReverseKittingOrder from './reverse-kitting-order'
+import * as ShippingOrder from './shipping-order'
 import * as TransferOrder from './transfer-order'
 import * as Vas from './vas'
-import * as Claim from './claim'
-import * as ClaimDetail from './claim-detail'
-import * as ClaimOrder from './claim-order'
 import * as VasOrder from './vas-order'
-import * as GoodsReceivalNote from './goods-receival-note'
-import * as Others from './others'
 
 export const queries = [
   Invoice.Query,
@@ -45,7 +46,8 @@ export const queries = [
   ClaimOrder.Query,
   VasOrder.Query,
   GoodsReceivalNote.Query,
-  Others.Query
+  Others.Query,
+  ReverseKittingOrder.Query
 ]
 
 export const mutations = [
@@ -71,5 +73,6 @@ export const mutations = [
   ClaimOrder.Mutation,
   VasOrder.Mutation,
   GoodsReceivalNote.Mutation,
-  Others.Mutation
+  Others.Mutation,
+  ReverseKittingOrder.Mutation
 ]

package/server/graphql/resolvers/order-reverse-kitting/index.ts

@@ -0,0 +1,9 @@
+import { orderReverseKittingResolver } from './order-reverse-kitting'
+import { orderReverseKittingsResolver } from './order-reverse-kittings'
+
+export const Query = {
+  ...orderReverseKittingResolver,
+  ...orderReverseKittingsResolver
+}
+
+export const Mutation = {}

package/server/graphql/resolvers/order-reverse-kitting/order-reverse-kitting.ts

@@ -0,0 +1,19 @@
+import { getRepository } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+
+import { OrderReverseKitting } from '../../../entities'
+
+export const orderReverseKittingResolver = {
+  async orderReverseKitting(_: any, { name }, context: any) {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(OrderReverseKitting).findOne({
+      where: {
+        domain,
+        name
+      },
+      relations: ['domain', 'reverseKittingOrder', 'vas', 'inventory', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/order-reverse-kitting/order-reverse-kittings.ts

@@ -0,0 +1,16 @@
+import { getRepository } from 'typeorm'
+
+import { convertListParams, ListParam } from '@things-factory/shell'
+
+import { OrderReverseKitting } from '../../../entities'
+
+export const orderReverseKittingsResolver = {
+  async orderReverseKittings(_: any, params: ListParam, context: any) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(OrderReverseKitting).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'reverseKittingOrder', 'vas', 'inventory', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/activate-reverse-kitting-order.ts

@@ -0,0 +1,47 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+
+export const activateReverseKittingOrderResolver = {
+  async activateReverseKittingOrder(_: any, { name }, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+    const reverseKittingOrder: ReverseKittingOrder = await activateReverseKittingOrderFunction(name, context, tx)
+
+    return reverseKittingOrder
+  }
+}
+
+export async function activateReverseKittingOrderFunction(
+  name: string,
+  context: any,
+  tx?: EntityManager
+): Promise<ReverseKittingOrder> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+    where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
+    relations: ['bizplace', 'orderReverseKittings', 'creator', 'updater']
+  })
+
+  let foundORKs: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
+
+  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
+  })
+
+  foundORKs = foundORKs.map((ork: OrderReverseKitting) => {
+    return { ...ork, status: ORDER_VAS_STATUS.PROCESSING }
+  })
+  await tx.getRepository(OrderReverseKitting).save(foundORKs)
+
+  return reverseKitting
+}

package/server/graphql/resolvers/reverse-kitting-order/cancel-reverse-kitting-order.ts

@@ -0,0 +1,47 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+
+export const cancelReverseKittingOrderResolver = {
+  async cancelReverseKittingOrder(_: any, { name }, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+    const reverseKittingOrder: ReverseKittingOrder = await cancelReverseKittingOrderFunction(name, context, tx)
+
+    return reverseKittingOrder
+  }
+}
+
+export async function cancelReverseKittingOrderFunction(
+  name: string,
+  context: any,
+  tx?: EntityManager
+): Promise<ReverseKittingOrder> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+    where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
+    relations: ['bizplace', 'orderReverseKittings', 'creator', 'updater']
+  })
+
+  let foundORKs: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
+
+  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.CANCELLED,
+    updater: user
+  })
+
+  foundORKs = foundORKs.map((ork: OrderReverseKitting) => {
+    return { ...ork, status: ORDER_VAS_STATUS.CANCELLED }
+  })
+  await tx.getRepository(OrderReverseKitting).save(foundORKs)
+
+  return reverseKitting
+}

package/server/graphql/resolvers/reverse-kitting-order/complete-reverse-kitting-order.ts

@@ -0,0 +1,59 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
+
+import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+import { InventoryUtil } from '../../../utils'
+
+export const completeReverseKittingOrderResolver = {
+  async completeReverseKittingOrder(_: any, { name }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+      where: { domain, name, status: ORDER_STATUS.EXECUTING },
+      relations: ['bizplace', 'orderReverseKittings', 'orderReverseKittings.inventory', 'creator', 'updater']
+    })
+
+    if (!foundReverseKittingOrder) throw new Error(foundReverseKittingOrder.name + ` not found`)
+
+    let orderReverseKittings: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
+
+    await Promise.all(
+      orderReverseKittings.map(async orderReverseKitting => {
+        let inventory: Inventory = orderReverseKitting.inventory
+        inventory.qty = inventory.qty - orderReverseKitting.qty
+        inventory.uomValue = inventory.uomValue - orderReverseKitting.uomValue
+
+        await InventoryUtil.transactionInventory(
+          inventory,
+          foundReverseKittingOrder,
+          -orderReverseKitting.qty,
+          -orderReverseKitting.uomValue,
+          INVENTORY_TRANSACTION_TYPE.REVERSE_KITTING,
+          user,
+          tx
+        )
+      })
+    )
+
+    orderReverseKittings = orderReverseKittings.map(orderReverseKitting => {
+      return {
+        ...orderReverseKitting,
+        status: ORDER_VAS_STATUS.TERMINATED,
+        updater: user
+      }
+    })
+
+    await tx.getRepository(OrderReverseKitting).save(orderReverseKittings)
+
+    foundReverseKittingOrder.status = ORDER_STATUS.DONE
+    foundReverseKittingOrder.updater = user
+
+    await tx.getRepository(ReverseKittingOrder).save(foundReverseKittingOrder)
+
+    return true
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/confirm-reverse-kitting-order.ts

@@ -0,0 +1,47 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { ORDER_STATUS, ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+
+export const confirmReverseKittingOrderResolver = {
+  async confirmReverseKittingOrder(_: any, { name }, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+    const reverseKittingOrder: ReverseKittingOrder = await confirmReverseKittingOrderFunction(name, context, tx)
+
+    return reverseKittingOrder
+  }
+}
+
+export async function confirmReverseKittingOrderFunction(
+  name: string,
+  context: any,
+  tx?: EntityManager
+): Promise<ReverseKittingOrder> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+    where: { domain, name, status: ORDER_STATUS.PENDING },
+    relations: ['bizplace', 'orderReverseKittings', 'creator', 'updater']
+  })
+
+  let foundORKs: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
+
+  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: OrderReverseKitting) => {
+    return { ...ork, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
+  })
+  await tx.getRepository(OrderReverseKitting).save(foundORKs)
+
+  return reverseKitting
+}

package/server/graphql/resolvers/reverse-kitting-order/delete-reverse-kitting-order.ts

@@ -0,0 +1,41 @@
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+
+export const deleteReverseKittingOrderResolver = {
+  async deleteReverseKittingOrder(_: any, { name }, context: any) {
+    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+
+    return await deleteReverseKittingOrder(tx, name, user, domain)
+  }
+}
+
+export async function deleteReverseKittingOrder(
+  tx: EntityManager,
+  name: string,
+  user: User,
+  domain: Domain
+): Promise<boolean> {
+  let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
+    where: { domain, name },
+    relations: ['bizplace', 'orderReverseKittings', 'creator', 'updater']
+  })
+
+  if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
+
+  const foundORKs: OrderReverseKitting[] = foundReverseKittingOrder.orderReverseKittings
+
+  // 1. delete order reverse kittings
+  const productIds = foundORKs.map((ork: OrderReverseKitting) => ork.id)
+  if (productIds.length) {
+    await tx.getRepository(OrderReverseKitting).delete({ id: In(productIds) })
+  }
+
+  // 2. delete Reverse Kitting Order
+  await tx.getRepository(ReverseKittingOrder).delete({ domain, name })
+
+  return true
+}

package/server/graphql/resolvers/reverse-kitting-order/execute-reverse-kitting.ts

@@ -0,0 +1,125 @@
+import { EntityManager, Equal, In, Not } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryNoGenerator,
+  Location,
+  LOCATION_TYPE,
+  Warehouse
+} from '@things-factory/warehouse-base'
+
+import { ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+import { InventoryUtil } from '../../../utils'
+
+export const executeReverseKittingResolver = {
+  async executeReverseKitting(_: any, { name, inventory }, context: any) {
+    const { tx }: { tx: EntityManager } = context.state
+    await executeReverseKittingFunction(name, inventory, context, tx)
+  }
+}
+
+export async function executeReverseKittingFunction(
+  name: string,
+  inventory: Partial<Inventory>,
+  context: any,
+  tx?: EntityManager
+): Promise<void> {
+  const { user, domain }: { user: User; domain: Domain } = context.state
+
+  let orderReverseKitting: OrderReverseKitting = await tx.getRepository(OrderReverseKitting).findOne({
+    where: {
+      name,
+      domain,
+      status: Not(Equal(ORDER_VAS_STATUS.READY_TO_PROCESS))
+    },
+    relations: ['bizplace', 'reverseKittingOrder', 'reverseKittingOrder.bizplace', 'inventory']
+  })
+
+  const foundReverseKittingOrder: ReverseKittingOrder = orderReverseKitting.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 = orderReverseKitting.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 = orderReverseKitting.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(orderReverseKitting.operationGuide)
+  let productCombinationSets: any[] = operationGuide.data.productCombinationSets
+  operationGuide.data.productCombinationSets = productCombinationSets.map(item => {
+    if (item.productDetailId == inventory.productDetailId) {
+      item.actualQty++
+    }
+    return item
+  })
+  orderReverseKitting.operationGuide = JSON.stringify(operationGuide)
+
+  await tx.getRepository(OrderReverseKitting).save(orderReverseKitting)
+}

package/server/graphql/resolvers/reverse-kitting-order/executing-reverse-kitting-order.ts

@@ -0,0 +1,40 @@
+import { getRepository, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { ORDER_STATUS } from '../../../constants'
+import { ReverseKittingOrder } from '../../../entities'
+
+export const executingReverseKittingOrderResolver = {
+  async executingReverseKittingOrder(_: any, { name }, context: any) {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+
+    const reverseKittingOrder: ReverseKittingOrder = await getRepository(ReverseKittingOrder).findOne({
+      where: {
+        domain,
+        name,
+        status: ORDER_STATUS.EXECUTING,
+        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'
+      ]
+    })
+
+    if (!reverseKittingOrder) throw new Error(`Reverse Kitting Order not exists`)
+
+    return reverseKittingOrder
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/generate-reverse-kitting-order.ts

@@ -0,0 +1,60 @@
+import { EntityManager } 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 { ORDER_STATUS, ORDER_TYPES, ORDER_VAS_STATUS } from '../../../constants'
+import { OrderReverseKitting, ReverseKittingOrder } from '../../../entities'
+import { OrderNoGenerator } from '../../../utils/order-no-generator'
+
+export const generateReverseKittingOrder = {
+  async generateReverseKittingOrder(_: any, { reverseKittingOrder }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: 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 orderReverseKittings: OrderReverseKitting[] = reverseKittingOrder.orderReverseKittings
+
+    // 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,
+      updater: user
+    })
+
+    // 2. Create Reverse Kitting Order Items
+    orderReverseKittings = await Promise.all(
+      orderReverseKittings.map(async (ork: OrderReverseKitting) => {
+        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(OrderReverseKitting).save(orderReverseKittings)
+
+    return createdReverseKittingOrder
+  }
+}

package/server/graphql/resolvers/reverse-kitting-order/index.ts

@@ -0,0 +1,28 @@
+import { activateReverseKittingOrderResolver } from './activate-reverse-kitting-order'
+import { cancelReverseKittingOrderResolver } from './cancel-reverse-kitting-order'
+import { completeReverseKittingOrderResolver } from './complete-reverse-kitting-order'
+import { confirmReverseKittingOrderResolver } from './confirm-reverse-kitting-order'
+import { deleteReverseKittingOrderResolver } from './delete-reverse-kitting-order'
+import { executeReverseKittingResolver } from './execute-reverse-kitting'
+import { executingReverseKittingOrderResolver } from './executing-reverse-kitting-order'
+import { generateReverseKittingOrder } from './generate-reverse-kitting-order'
+import { reverseKittingInventoriesResolver } from './reverse-kitting-inventories'
+import { reverseKittingOrderResolver } from './reverse-kitting-order'
+import { reverseKittingOrdersResolver } from './reverse-kitting-orders'
+
+export const Query = {
+  ...reverseKittingOrdersResolver,
+  ...reverseKittingOrderResolver,
+  ...executingReverseKittingOrderResolver,
+  ...reverseKittingInventoriesResolver
+}
+
+export const Mutation = {
+  ...generateReverseKittingOrder,
+  ...confirmReverseKittingOrderResolver,
+  ...activateReverseKittingOrderResolver,
+  ...deleteReverseKittingOrderResolver,
+  ...cancelReverseKittingOrderResolver,
+  ...executeReverseKittingResolver,
+  ...completeReverseKittingOrderResolver
+}