@things-factory/sales-base 4.0.10 → 4.0.14

package/server/service/release-good/release-good-query.ts

@@ -4,12 +4,19 @@ import { EntityManager, getRepository, In, Repository, SelectQueryBuilder } from
 
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
-import { Bizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Bizplace, getCompanyBizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
-import { InventoryInfos, OrderInventory, ReleasableInventoryList, ReleaseGoodList, ShippingOrder } from '../'
+import {
+  InventoryInfos,
+  NewReleaseGood,
+  OrderInventory,
+  ReleasableInventoryList,
+  ReleaseGoodList,
+  ShippingOrder
+} from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '../../constants'
 import { ReleaseGood } from './release-good'
 
@@ -463,6 +470,129 @@ export class ReleaseGoodQuery {
     }
   }
 
+  @Directive('@transaction')
+  @Query(returns => [ReleaseGood])
+  async bulkReleaseGoodsAvailableItems(
+    @Ctx() context: any,
+    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ReleaseGood[]> {
+    const { domain, tx } = context.state
+    const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+    if (!rawReleaseGoods) return
+
+    const json_oi = JSON.stringify(
+      rawReleaseGoods.map(raw => {
+        return {
+          sku: raw.sku,
+          packing_type: raw.packingType,
+          packing_size: raw.packingSize,
+          uom: raw.uom,
+          release_qty: raw.releaseQty
+        }
+      })
+    )
+
+    await tx.query(
+      `
+        CREATE TEMP TABLE temp_order_products(
+          product_id VARCHAR(50),
+          sku VARCHAR(150),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+          );
+      `
+    )
+
+    await tx.query(
+      `
+        INSERT INTO temp_order_products
+        SELECT p.id AS product_id, js.sku,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
+        js.release_qty
+        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
+        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
+        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
+      `,
+      [companyBizplaceId.id]
+    )
+
+    let availableItems = await tx.query(
+      `
+        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) FROM order_inventories oi 
+              WHERE (
+                oi.status = 'PENDING'
+                OR oi.status = 'PENDING_RECEIVE'
+                OR oi.status = 'PENDING_WORKSHEET'
+                OR oi.status = 'PENDING_SPLIT'
+              )
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
+              WHERE (
+                oi.status = 'PENDING'
+                OR oi.status = 'PENDING_RECEIVE'
+                OR oi.status = 'PENDING_WORKSHEET'
+                OR oi.status = 'PENDING_SPLIT'
+              )
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        INNER JOIN (
+          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
+          FROM temp_order_products top
+          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      `,
+      [domain.id, bizplaceId]
+    )
+
+    await tx.query('DROP TABLE temp_order_products')
+
+    availableItems = availableItems.map(item => {
+      return {
+        productId: item.product_id,
+        sku: item.sku,
+        batchId: item.batch_id,
+        packingType: item.packing_type,
+        packingSize: item.packing_size,
+        uom: item.uom,
+        remainQty: item.remain_qty,
+        remainUomValue: item.remain_uom_value
+      }
+    })
+
+    return _extractData(rawReleaseGoods, availableItems)
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() releaseGood: ReleaseGood): Promise<Domain> {
     return await getRepository(Domain).findOne(releaseGood.domainId)
@@ -559,6 +689,71 @@ async function dropOITempTable(domain: Domain, tx: EntityManager) {
   await tx.query(`DROP TABLE oi`)
 }
 
+function _extractData(rawData, validatedData) {
+  return rawData.map(raw => {
+    const idx = validatedData.findIndex(val => {
+      const comparison = ['packingType', 'packingSize', 'uom']
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc]) {
+          a[cc] = raw[cc]
+          b[cc] = val[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return val.sku == raw.sku && a === b
+    })
+
+    let releaseUomValue = 0
+
+    // if sku is matched, assign qty and product id
+    if (idx >= 0) {
+      // assign qty to rawData as much as possible
+      releaseUomValue =
+        (Math.round((validatedData[idx]?.remainUomValue / validatedData[idx]?.remainQty) * 100) / 100) * raw.releaseQty
+
+      raw.assignedQty =
+        validatedData[idx].remainQty >= raw.releaseQty
+          ? raw.releaseQty > 0
+            ? raw.releaseQty
+            : 0
+          : validatedData[idx].remainQty
+
+      raw.assignedUomValue =
+        validatedData[idx].remainUomValue >= releaseUomValue
+          ? releaseUomValue > 0
+            ? releaseUomValue
+            : 0
+          : validatedData[idx].remainUomValue
+
+      // deduct qty & uomValue from validateData
+      validatedData[idx].remainQty -= raw.assignedQty
+      validatedData[idx].remainUomValue -= raw.assignedUomValue
+
+      raw.productId = validatedData[idx].productId
+      raw.packingType = validatedData[idx].packingType
+      raw.packingSize = validatedData[idx].packingSize
+      raw.uom = validatedData[idx].uom
+      raw.batchId = validatedData[idx].batchId
+    } else {
+      raw.assignedQty = 0
+      raw.assignedUomValue = 0
+      raw.productId = null
+    }
+
+    return {
+      ...raw,
+      releaseUomValue
+    }
+  })
+}
+
 function getConditionValues(
   conditions: Filter[]
 ): {

package/server/service/release-good/release-good-types.ts

@@ -121,10 +121,19 @@ export class InventoryInfos {
 
   @Field({ nullable: true })
   remark?: string
+
+  @Field({ nullable: true })
+  lockedQty?: number
+
+  @Field({ nullable: true })
+  lockedUomValue?: number
 }
 
 @ObjectType()
 export class ShippingOrderInfo {
+  @Field({ nullable: true })
+  id?: string
+
   @Field({ nullable: true })
   containerNo?: string
 
@@ -272,11 +281,11 @@ export class NewReleaseGood {
   @Field(type => ObjectRef, { nullable: true })
   shippingOrder: ObjectRef
 
-  @Field(type => NewOrderInventory, { nullable: true })
-  orderInventories: [NewOrderInventory]
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: NewOrderInventory[]
 
-  @Field(type => NewOrderVas, { nullable: true })
-  orderVass: [NewOrderVas]
+  @Field(type => [NewOrderVas], { nullable: true })
+  orderVass: NewOrderVas[]
 
   @Field({ nullable: true })
   status: string
@@ -295,6 +304,21 @@ export class NewReleaseGood {
 
   @Field({ nullable: true })
   partnerBizplaceId: string
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field({ nullable: true })
+  packingSize: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  releaseQty: string
 }
 
 @InputType()
@@ -372,13 +396,13 @@ export class ReleaseGoodPatch {
   shippingOrder: ObjectRef
 
   @Field(type => [ObjectRef], { nullable: true })
-  deliveryOrders: [ObjectRef]
+  deliveryOrders: ObjectRef[]
 
   @Field(type => [ObjectRef], { nullable: true })
-  orderInventories: [ObjectRef]
+  orderInventories: ObjectRef[]
 
   @Field(type => [ObjectRef], { nullable: true })
-  orderVass: [ObjectRef]
+  orderVass: ObjectRef[]
 
   @Field({ nullable: true })
   status: string

package/server/service/release-good/release-good.ts

@@ -23,6 +23,7 @@ import {
   ArrivalNotice,
   DeliveryOrder,
   InventoryInfos,
+  Manifest,
   OrderInventory,
   OrderProduct,
   OrderVas,
@@ -37,6 +38,11 @@ export enum ReleaseOrderType {
   B2B = 'b2b',
   B2C = 'b2c'
 }
+
+export enum DispatchmentStatus {
+  READY_TO_DISPATCH = 'READY_TO_DISPATCH',
+  DISPATCHED = 'DISPATCHED'
+}
 @Entity()
 @Index('ix_release-good_0', (releaseGood: ReleaseGood) => [releaseGood.domain, releaseGood.name], { unique: true })
 @ObjectType()
@@ -59,6 +65,10 @@ export class ReleaseGood {
   @RelationId((releaseGood: ReleaseGood) => releaseGood.bizplace)
   bizplaceId: string
 
+  @ManyToOne(type => Manifest)
+  @Field(type => Manifest, { nullable: true })
+  manifest: Manifest
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   name: string
@@ -143,6 +153,18 @@ export class ReleaseGood {
   @Field()
   status: string
 
+  @Column({
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+        ? 'varchar2'
+        : 'smallint',
+    enum: DispatchmentStatus,
+    default: DispatchmentStatus.READY_TO_DISPATCH
+  })
+  dispatchmentStatus: DispatchmentStatus
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   releaseDateTime: Date
@@ -267,6 +289,10 @@ export class ReleaseGood {
   @Field({ nullable: true })
   invoice: string
 
+  @Column({ type: 'int', nullable: true })
+  @Field({ nullable: true })
+  noOfItems: number
+
   @CreateDateColumn()
   @Field()
   createdAt: Date

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

@@ -1,14 +1,15 @@
 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 { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
   Inventory,
-  InventoryPatch,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryHistory,
   InventoryNoGenerator,
+  InventoryPatch,
   InventoryUtil,
   Location,
   LOCATION_TYPE,
@@ -51,20 +52,26 @@ export class ReverseKittingOrderMutation {
 
     // 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)
+      reverseKittingOrderOIs.map(async (reverseKittingOI: any) => {
+        if (reverseKittingOI?.inventory?.id) {
+          const foundInv: Inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+          reverseKittingOI.inventory = foundInv
+
+          foundInv.lockedQty = Number(foundInv.lockedQty) + reverseKittingOI.qty
+          foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + reverseKittingOI.uomValue
+          foundInv.updater = user
+
+          await tx.getRepository(Inventory).save(foundInv)
         }
         return {
-          ...ork,
+          ...reverseKittingOI,
           domain,
           name: OrderNoGenerator.orderVas(),
           reverseKittingOrder: createdReverseKittingOrder,
           bizplace: customerBizplace,
           type: ORDER_TYPES.VAS_ORDER,
           status: ORDER_VAS_STATUS.PENDING,
-          creator: user,
-          updater: user
+          creator: user
         }
       })
     )
@@ -113,7 +120,7 @@ export class ReverseKittingOrderMutation {
       relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
     })
 
-    let foundORKs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
 
     if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
 
@@ -124,10 +131,10 @@ export class ReverseKittingOrderMutation {
       updater: user
     })
 
-    foundORKs = foundORKs.map((ork: ReverseKittingOrderInventory) => {
-      return { ...ork, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
+    reverseKittingOIs = reverseKittingOIs.map((reverseKittingOI: ReverseKittingOrderInventory) => {
+      return { ...reverseKittingOI, status: ORDER_VAS_STATUS.READY_TO_PROCESS }
     })
-    await tx.getRepository(ReverseKittingOrderInventory).save(foundORKs)
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
 
     return reverseKitting
   }
@@ -150,14 +157,15 @@ export class ReverseKittingOrderMutation {
 
     if (!foundReverseKittingOrder) throw new Error(foundReverseKittingOrder.name + ` not found`)
 
-    let reverseKittingOrderInventories: ReverseKittingOrderInventory[] =
-      foundReverseKittingOrder.reverseKittingOrderInventories
+    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
 
     await Promise.all(
-      reverseKittingOrderInventories.map(async reverseKittingOI => {
+      reverseKittingOIs.map(async reverseKittingOI => {
         let inventory: Inventory = reverseKittingOI.inventory
         inventory.qty = inventory.qty - reverseKittingOI.qty
+        inventory.lockedQty = inventory.lockedQty - reverseKittingOI.qty
         inventory.uomValue = inventory.uomValue - reverseKittingOI.uomValue
+        inventory.lockedUomValue = inventory.lockedUomValue - reverseKittingOI.uomValue
 
         await InventoryUtil.transactionInventory(
           inventory,
@@ -171,7 +179,7 @@ export class ReverseKittingOrderMutation {
       })
     )
 
-    reverseKittingOrderInventories = reverseKittingOrderInventories.map(reverseKittingOI => {
+    reverseKittingOIs = reverseKittingOIs.map(reverseKittingOI => {
       return {
         ...reverseKittingOI,
         status: ORDER_VAS_STATUS.TERMINATED,
@@ -179,7 +187,7 @@ export class ReverseKittingOrderMutation {
       }
     })
 
-    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOrderInventories)
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
 
     foundReverseKittingOrder.status = ORDER_STATUS.DONE
     foundReverseKittingOrder.updater = user
@@ -196,27 +204,109 @@ export class ReverseKittingOrderMutation {
 
     const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
       where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
-      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
+      relations: [
+        'bizplace',
+        'reverseKittingOrderInventories',
+        'reverseKittingOrderInventories.inventory',
+        'creator',
+        'updater'
+      ]
     })
 
-    let foundKOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+    let reverseKittingOIs: 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.CANCELLED,
       updater: user
     })
 
-    foundKOIs = foundKOIs.map((ork: ReverseKittingOrderInventory) => {
-      return { ...ork, status: ORDER_VAS_STATUS.CANCELLED }
-    })
-    await tx.getRepository(ReverseKittingOrderInventory).save(foundKOIs)
+    reverseKittingOIs = await Promise.all(
+      reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
+        if (reverseKittingOI?.inventory?.id) {
+          reverseKittingOI.inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+
+          await tx.getRepository(Inventory).save({
+            ...reverseKittingOI.inventory,
+            lockedQty: reverseKittingOI.inventory.lockedQty - reverseKittingOI.qty,
+            lockedUomValue: reverseKittingOI.inventory.lockedUomValue - reverseKittingOI.uomValue,
+            updater: user
+          })
+        }
+
+        return { ...reverseKittingOI, status: ORDER_VAS_STATUS.CANCELLED }
+      })
+    )
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
 
     return reverseKitting
   }
 
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To undo the execution of reverse kitting order' })
+  async undoReverseKittingInventory(
+    @Arg('reverseKittingOIName') reverseKittingOIName: string,
+    @Arg('palletId') palletId: string,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx, domain, user } = context.state
+
+    //@sumjoekin please add stricter validation. It is dangerous without strict validation. Unexpected behaviour will cause accidental deletion of inventory.
+
+    const reverseKittingOI: ReverseKittingOrderInventory = await tx
+      .getRepository(ReverseKittingOrderInventory)
+      .findOne({
+        where: { domain, name: reverseKittingOIName },
+        relations: ['bizplace', 'reverseKittingOrder']
+      })
+
+    const bizplace: Bizplace = reverseKittingOI.bizplace
+    const reverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
+    let foundInventory: Inventory = await tx.getRepository(Inventory).findOne({
+      where: { domain, bizplace, orderVasId: reverseKittingOI.id, palletId },
+      relations: ['bizplace', 'product']
+    })
+    if (!foundInventory) throw new Error(`There's no results matched with condition ${foundInventory.palletId}`)
+
+    let operationGuide: any = JSON.parse(reverseKittingOI.operationGuide)
+    let productCombinationSets: any[] = operationGuide.data.productCombinationSets
+    productCombinationSets = productCombinationSets.map(item => {
+      if (foundInventory.product.id == item.productId) {
+        item.actualQty -= foundInventory.qty
+      }
+      return item
+    })
+    operationGuide.data.productCombinationSets = productCombinationSets
+
+    await tx
+      .getRepository(ReverseKittingOrderInventory)
+      .update({ id: reverseKittingOI.id }, { operationGuide: operationGuide })
+
+    foundInventory.lastSeq++
+    foundInventory.status = INVENTORY_STATUS.DELETED
+    foundInventory = await InventoryUtil.transactionInventory(
+      foundInventory,
+      reverseKittingOrder,
+      -foundInventory.qty,
+      -foundInventory.uomValue,
+      INVENTORY_TRANSACTION_TYPE.UNDO_REVERSE_KITTING,
+      user,
+      tx
+    )
+    foundInventory.qty = 0
+    foundInventory.uomValue = 0
+    foundInventory.updater = user
+
+    await tx.getRepository(InventoryHistory).update({ inventory: foundInventory }, { inventory: null })
+
+    await tx.getRepository(Inventory).delete({ id: foundInventory.id })
+
+    return true
+  }
+
   @Directive('@transaction')
   @Mutation(returns => ReverseKittingOrder, { description: 'To activate reverse kitting order' })
   async activateReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
@@ -227,7 +317,7 @@ export class ReverseKittingOrderMutation {
       relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
     })
 
-    let foundKOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
+    let reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
 
     if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
 
@@ -238,10 +328,10 @@ export class ReverseKittingOrderMutation {
       updater: user
     })
 
-    foundKOIs = foundKOIs.map((ork: ReverseKittingOrderInventory) => {
-      return { ...ork, status: ORDER_VAS_STATUS.PROCESSING }
+    reverseKittingOIs = reverseKittingOIs.map((reverseKittingOI: ReverseKittingOrderInventory) => {
+      return { ...reverseKittingOI, status: ORDER_VAS_STATUS.PROCESSING }
     })
-    await tx.getRepository(ReverseKittingOrderInventory).save(foundKOIs)
+    await tx.getRepository(ReverseKittingOrderInventory).save(reverseKittingOIs)
 
     return reverseKitting
   }
@@ -268,13 +358,9 @@ export class ReverseKittingOrderMutation {
     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
-      },
+      where: { id: inventory.productDetailId },
       relations: ['product']
     })
 
@@ -318,6 +404,7 @@ export class ReverseKittingOrderMutation {
     newInventory.warehouse = warehouse
     newInventory.location = location
     newInventory.zone = zone
+    newInventory.refInventory = reverseKittingOI.inventory
     newInventory.status = INVENTORY_STATUS.STORED
     newInventory.domain = domain
     newInventory.creator = user
@@ -337,7 +424,7 @@ export class ReverseKittingOrderMutation {
     let productCombinationSets: any[] = operationGuide.data.productCombinationSets
     operationGuide.data.productCombinationSets = productCombinationSets.map(item => {
       if (item.productDetailId == inventory.productDetailId) {
-        item.actualQty++
+        item.actualQty += qty
       }
       return item
     })
@@ -350,16 +437,39 @@ export class ReverseKittingOrderMutation {
   @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
+    const { domain, tx, user } = context.state
     let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
       where: { domain, name },
-      relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
+      relations: [
+        'bizplace',
+        'reverseKittingOrderInventories',
+        'reverseKittingOrderInventories.inventory',
+        'creator',
+        'updater'
+      ]
     })
 
     if (!foundReverseKittingOrder) throw new Error(`Reverse kitting order doesn't exists.`)
 
     const reverseKittingOIs: ReverseKittingOrderInventory[] = foundReverseKittingOrder.reverseKittingOrderInventories
 
+    // Delete order reverse kittings by ids
+    await Promise.all(
+      reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
+        if (reverseKittingOI?.inventory?.id) {
+          reverseKittingOI.inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+
+          await tx.getRepository(Inventory).save({
+            ...reverseKittingOI.inventory,
+            lockedQty: reverseKittingOI.inventory.lockedQty - reverseKittingOI.qty,
+            lockedUomValue: reverseKittingOI.inventory.lockedUomValue - reverseKittingOI.uomValue,
+            updater: user
+          })
+        }
+        return reverseKittingOI
+      })
+    )
+
     // 1. delete order reverse kittings
     const productIds = reverseKittingOIs.map((ork: ReverseKittingOrderInventory) => ork.id)
     if (productIds.length) {