@things-factory/worksheet-base 4.3.239 → 4.3.242

package/dist-server/graphql/types/worksheet/worksheet-detail-info.js

@@ -43,6 +43,7 @@ exports.WorksheetDetailInfo = (0, apollo_server_koa_1.gql) `
     targetType: String
     targetBatchId: String
     targetProduct: Product
+    targetVas: OrderVas
     otherTarget: String
     vas: Vas
     targetName: String

package/dist-server/graphql/types/worksheet/worksheet-detail-info.js.map

@@ -1 +1 @@
-{"version":3,"file":"worksheet-detail-info.js","sourceRoot":"","sources":["../../../../server/graphql/types/worksheet/worksheet-detail-info.ts"],"names":[],"mappings":";;;AAAA,yDAAuC;AAE1B,QAAA,mBAAmB,GAAG,IAAA,uBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsErC,CAAA"}
+{"version":3,"file":"worksheet-detail-info.js","sourceRoot":"","sources":["../../../../server/graphql/types/worksheet/worksheet-detail-info.ts"],"names":[],"mappings":";;;AAAA,yDAAuC;AAE1B,QAAA,mBAAmB,GAAG,IAAA,uBAAG,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuErC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worksheet-base",
-  "version": "4.3.239",
+  "version": "4.3.242",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -36,12 +36,12 @@
     "@things-factory/integration-sftp": "^4.3.239",
     "@things-factory/marketplace-base": "^4.3.239",
     "@things-factory/notification": "^4.3.237",
-    "@things-factory/sales-base": "^4.3.239",
+    "@things-factory/sales-base": "^4.3.241",
     "@things-factory/setting-base": "^4.3.237",
     "@things-factory/shell": "^4.3.237",
     "@things-factory/transport-base": "^4.3.237",
-    "@things-factory/warehouse-base": "^4.3.239",
+    "@things-factory/warehouse-base": "^4.3.241",
     "uuid": "^9.0.0"
   },
-  "gitHead": "ed967aa995647ed1ebd4dd08d162d3a7ffddee51"
+  "gitHead": "bed41128f2997bc35a711b1ab73d17b8334567e7"
 }

package/server/controllers/outbound/loading-worksheet-controller.ts

@@ -1,4 +1,4 @@
-import { Equal, In, Not } from 'typeorm'
+import { Equal, In, Not, IsNull } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import {
@@ -10,6 +10,7 @@ import {
   OrderNoGenerator,
   OrderTote,
   OrderToteItem,
+  OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
 import {
@@ -112,6 +113,7 @@ export class LoadingWorksheetController extends VasWorksheetController {
     const bizplace: Bizplace = releaseGood.bizplace
 
     for (let i = 0; i < worksheetDetails.length; i++) {
+      // const pickedQty: number = worksheetDetails[i].pickedQty
       const loadedQty: number = worksheetDetails[i].loadedQty
       const toteName: string = worksheetDetails[i].toteName
       let worksheetDetail = await this.findExecutableWorksheetDetailByName(
@@ -132,7 +134,10 @@ export class LoadingWorksheetController extends VasWorksheetController {
 
       const worksheet: Worksheet = worksheetDetail.worksheet
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
-      const pickedQty: number = targetInventory.releaseQty
+      const pickedQty: number =
+        targetInventory.type === ORDER_TYPES.VAS_ORDER || targetInventory.releaseQty != targetInventory.pickedQty
+          ? targetInventory.releaseQty
+          : targetInventory.pickedQty
       let inventory: Inventory = targetInventory.inventory
 
       targetInventory.loadedAt = new Date()
@@ -164,7 +169,14 @@ export class LoadingWorksheetController extends VasWorksheetController {
         const remainUomValue: number = parseFloat((targetInventory.releaseUomValue - loadedUomValue).toFixed(2))
 
         targetInventory.status = ORDER_INVENTORY_STATUS.LOADED
-        targetInventory.releaseQty = loadedQty
+        targetInventory.releaseQty =
+          targetInventory.type === ORDER_TYPES.VAS_ORDER || targetInventory.releaseQty != targetInventory.pickedQty
+            ? remainQty
+            : targetInventory.releaseQty
+        targetInventory.pickedQty =
+          targetInventory.type === ORDER_TYPES.VAS_ORDER || targetInventory.releaseQty != targetInventory.pickedQty
+            ? targetInventory.pickedQty
+            : loadedQty
         targetInventory.releaseUomValue = loadedUomValue
         targetInventory.updater = this.user
         await this.updateOrderTargets([targetInventory])
@@ -180,9 +192,16 @@ export class LoadingWorksheetController extends VasWorksheetController {
         newTargetInventory.name = OrderNoGenerator.orderInventory()
         newTargetInventory.releaseGood = releaseGood
         newTargetInventory.inventory = inventory
-        newTargetInventory.type = ORDER_TYPES.RELEASE_OF_GOODS
+        newTargetInventory.type = targetInventory.type
         newTargetInventory.status = ORDER_INVENTORY_STATUS.LOADING
-        newTargetInventory.releaseQty = remainQty
+        newTargetInventory.releaseQty =
+          targetInventory.type === ORDER_TYPES.VAS_ORDER || targetInventory.releaseQty != targetInventory.pickedQty
+            ? remainQty
+            : targetInventory.releaseQty
+        newTargetInventory.pickedQty =
+          targetInventory.type === ORDER_TYPES.VAS_ORDER || targetInventory.releaseQty != targetInventory.pickedQty
+            ? targetInventory.pickedQty
+            : remainQty
         newTargetInventory.releaseUomValue = remainUomValue
         newTargetInventory.product = targetInventory.product
         newTargetInventory.productDetail = targetInventory.productDetail
@@ -257,7 +276,7 @@ export class LoadingWorksheetController extends VasWorksheetController {
     return worksheetDetails
   }
 
-  async undoLoading(deliveryOrder: Partial<DeliveryOrder>, palletIds: string[]): Promise<void> {
+  async undoLoading(deliveryOrder: Partial<DeliveryOrder>, palletIds: string[], productIds: string[]): Promise<void> {
     deliveryOrder = await this.findRefOrder(DeliveryOrder, { id: deliveryOrder.id, domain: this.domain }, [
       'releaseGood'
     ])
@@ -266,13 +285,15 @@ export class LoadingWorksheetController extends VasWorksheetController {
 
     const targetInventories: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, deliveryOrder, status: ORDER_INVENTORY_STATUS.LOADED },
-      relations: ['inventory']
+      relations: ['inventory', 'product', 'deliveryOrder']
     })
     // Filter out inventories which is included palletIds list.
     let undoTargetOrderInventories: OrderInventory[] = targetInventories.filter(
       (targetInventory: OrderInventory) =>
         targetInventory.status === ORDER_INVENTORY_STATUS.LOADED &&
-        palletIds.includes(targetInventory.inventory.palletId)
+        palletIds.includes(targetInventory.inventory.palletId) &&
+        // productIds.includes(targetInventory.product.id) &&
+        deliveryOrder.id === targetInventory.deliveryOrder.id
     )
 
     // If there was remained items => Merge into previous order inventories
@@ -290,7 +311,8 @@ export class LoadingWorksheetController extends VasWorksheetController {
           id: Not(Equal(undoTargetOrderInventory.id)),
           releaseGood,
           status: ORDER_INVENTORY_STATUS.LOADING,
-          inventory: undoTargetOrderInventory.inventory
+          inventory: undoTargetOrderInventory.inventory,
+          product: undoTargetOrderInventory.product
         }
       })
 
@@ -301,7 +323,13 @@ export class LoadingWorksheetController extends VasWorksheetController {
       if (prevTargetInventory) {
         // If there's prev target inventory
         // Merge qty and uomValue into prev target inventory
-        prevTargetInventory.releaseQty += undoTargetOrderInventory.releaseQty
+        if (prevTargetInventory.type === ORDER_TYPES.VAS_ORDER) {
+          prevTargetInventory.releaseQty += undoTargetOrderInventory.releaseQty
+          prevTargetInventory.pickedQty = undoTargetOrderInventory.pickedQty
+        } else {
+          prevTargetInventory.releaseQty = undoTargetOrderInventory.releaseQty
+          prevTargetInventory.pickedQty += undoTargetOrderInventory.pickedQty
+        }
         prevTargetInventory.releaseUomValue += undoTargetOrderInventory.releaseUomValue
         prevTargetInventory.updater = this.user
         await this.updateOrderTargets([prevTargetInventory])

package/server/controllers/outbound/picking-worksheet-controller.ts

@@ -222,12 +222,13 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
 
-    try {
-      const vasWorksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.VAS)
-      if (vasWorksheet) {
-        await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
-      }
-    } catch (e) {}
+    // VAS will be activated after PICKING is completed
+    // try {
+    //   const vasWorksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.VAS)
+    //   if (vasWorksheet) {
+    //     await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
+    //   }
+    // } catch (e) {}
 
     const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
       where: { domain: this.domain, releaseGood, status: ORDER_INVENTORY_STATUS.PENDING_SPLIT }
@@ -1340,9 +1341,15 @@ export class PickingWorksheetController extends VasWorksheetController {
       await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
     }
 
+    let orderVas: OrderVas[] = await this.trxMgr
+      .getRepository(OrderVas)
+      .find({ where: { releaseGood: releaseGood.id } })
+
     let orderStatus: string
     if (releaseGood?.packingOption) {
       orderStatus = ORDER_STATUS.READY_TO_PACK
+    } else if (orderVas.length > 0) {
+      orderStatus = ORDER_STATUS.VAS
     } else {
       orderStatus = ORDER_STATUS.LOADING
     }

package/server/controllers/render-ro-do.ts

@@ -120,6 +120,7 @@ export async function renderRODO({ doNo }, context: any) {
   wdQb
     .leftJoinAndSelect('wd.targetInventory', 'targetInventory')
     .leftJoinAndSelect('targetInventory.inventory', 'inventory')
+    .leftJoinAndSelect('targetInventory.product', 'oiProduct')
     .leftJoinAndSelect('inventory.location', 'location')
     .leftJoinAndSelect('inventory.product', 'product')
     .leftJoinAndSelect('product.productDetails', 'productDetails')
@@ -174,20 +175,38 @@ export async function renderRODO({ doNo }, context: any) {
         productDetail => productDetail.packingType === inventory.packingType
       )
       return {
-        product_name: `${inventory.product.name} (${inventory.product.description})`,
-        product_desc: `${inventory.product?.description || ''}`,
-        product_nameOnly: `${inventory.product.name}`,
-        product_sku: `${inventory.product.sku}`,
+        product_name:
+          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+            ? `${inventory.product.name} (${inventory.product.description})`
+            : `${wsd.targetInventory.product.name} (${wsd.targetInventory.product.description})`,
+        product_desc:
+          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+            ? `${inventory.product?.description || ''}`
+            : `${wsd.targetInventory.product.description || ''}`,
+        product_nameOnly:
+          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+            ? `${inventory.product.name}`
+            : `${wsd.targetInventory.product.name}`,
+        product_sku:
+          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+            ? `${inventory.product.sku}`
+            : `${wsd.targetInventory.product.sku}`,
         product_type: inventory.packingType,
         product_size: matchedProductDetail ? matchedProductDetail.packingSize : inventory.packingSize,
         product_batch: inventory.batchId,
         product_batch_ref: inventory.batchIdRef,
-        product_qty: targetInventory.releaseQty,
+        product_qty:
+          targetInventory.type === 'VAS_ORDER' || targetInventory.releaseQty != targetInventory.pickedQty
+            ? targetInventory.releaseQty
+            : targetInventory.pickedQty,
         product_weight: targetInventory.releaseWeight,
         product_gross_weight: inventory.product.grossWeight,
         product_uom_value: targetInventory.releaseUomValue,
         product_uom: inventory.uom,
-        product_brand_sku: `${inventory.product?.brandSku || ''}`,
+        product_brand_sku:
+          wsd.targetInventory.product.id === wsd.targetInventory.inventory.product.id
+            ? `${inventory.product?.brandSku || ''}`
+            : `${wsd.targetInventory.product?.brandSku || ''}`,
         remark: targetInventory.remark,
         inventory_remark: inventory.remark,
         cross_docking: targetInventory.crossDocking,

package/server/controllers/vas/vas-worksheet-controller.ts

@@ -1,13 +1,16 @@
-import { EntityManager, Equal, In, Not } from 'typeorm'
+import { EntityManager, Equal, In, Not, getRepository, IsNull } from 'typeorm'
 
+import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import {
   ArrivalNotice,
+  OrderInventory,
   ORDER_STATUS,
   ORDER_TYPES,
   ORDER_VAS_STATUS,
+  ORDER_INVENTORY_STATUS,
   OrderNoGenerator,
   OrderVas,
   ReleaseGood,
@@ -38,6 +41,8 @@ import {
 } from '../../graphql/resolvers/worksheet/vas-transactions'
 import { PackingUnits } from '../../graphql/resolvers/worksheet/vas-transactions/interfaces/repackaging'
 import { ReferenceOrderType, WorksheetController } from '../worksheet-controller'
+import { LoadingWorksheetController } from '../../controllers'
+import { v4 as uuidv4 } from 'uuid'
 
 type CompleteTransactionType = (trxMgr: EntityManager, orderVas: OrderVas, user: User) => Promise<void>
 
@@ -681,7 +686,14 @@ export class VasWorksheetController extends WorksheetController {
     return inventory
   }
 
-  async completeVAS(orderNo: string, orderType: string, vasWorksheetDetails: WorksheetDetail[]): Promise<Worksheet> {
+  async completeVAS(
+    tx: any,
+    domain: Domain,
+    user: User,
+    orderNo: string,
+    orderType: string,
+    vasWorksheetDetails: WorksheetDetail[]
+  ): Promise<Worksheet> {
     const ENTITY_MAP: { [key: string]: ArrivalNotice | ReleaseGood | VasOrder } = {
       [ORDER_TYPES.ARRIVAL_NOTICE]: ArrivalNotice,
       [ORDER_TYPES.RELEASE_OF_GOODS]: ReleaseGood,
@@ -695,7 +707,9 @@ export class VasWorksheetController extends WorksheetController {
       'worksheetDetails',
       'worksheetDetails.targetVas',
       'worksheetDetails.targetVas.vas',
-      'worksheetDetails.targetVas.inventory'
+      'worksheetDetails.targetVas.inventory',
+      'worksheetDetails.targetVas.orderVasItems',
+      'worksheetDetails.targetVas.orderVasItems.vas'
     ])
 
     const isPureVAS: boolean = refOrder instanceof VasOrder
@@ -735,56 +749,59 @@ export class VasWorksheetController extends WorksheetController {
     }, [])
 
     for (const targetVas of targetVASs) {
-      const { issue }: { issue: string } = foundWorksheetDetails.find(
-        (wsd: WorksheetDetail) => wsd.targetVas.id === targetVas.id
-      )
-
-      // if (targetVas.operationGuide && (!issue || (targetVas.vas.name.toUpperCase() == VAS.REPACKAGING && issue))) {
-      //   await this.doOperationTransaction(targetVas)
-      // } /*else if (targetVas.operationGuide && targetVas.vas.name.toUpperCase() === VAS.REPACKAGING && issue) {
-      //   await this.doOperationTransaction(targetVas)
-      // }*/
+      if (targetVas.vas) {
+        // for old vas--> can be removed later
+        const { issue }: { issue: string } = foundWorksheetDetails.find(
+          (wsd: WorksheetDetail) => wsd.targetVas.id === targetVas.id
+        )
 
-      if (targetVas.operationGuide && !issue) {
-        await this.doOperationTransaction(targetVas)
-      }
+        // if (targetVas.operationGuide && (!issue || (targetVas.vas.name.toUpperCase() == VAS.REPACKAGING && issue))) {
+        //   await this.doOperationTransaction(targetVas)
+        // } /*else if (targetVas.operationGuide && targetVas.vas.name.toUpperCase() === VAS.REPACKAGING && issue) {
+        //   await this.doOperationTransaction(targetVas)
+        // }*/
 
-      if (targetVas.vas.name.toUpperCase() === VAS.UNPACKING && !(refOrder instanceof ArrivalNotice)) {
-        // Update qty and uom value of parent inventory (only applies for pure vas and RO)
-        const parentInventory: Inventory = targetVas.inventory
-        let newParentInventory: Partial<Inventory> = Object.assign({}, parentInventory)
-        newParentInventory.qty = parentInventory.qty - targetVas.qty
-        newParentInventory.uomValue = Math.round((parentInventory.uomValue - targetVas.uomValue) * 100) / 100
-        newParentInventory.lockedQty = parentInventory.lockedQty - targetVas.qty
-        newParentInventory.lockedUomValue =
-          Math.round((parentInventory.lockedUomValue - targetVas.uomValue) * 100) / 100
-
-        // update qty and uomValue for VasOrder
-        // if refOrder is from ReleaseGood, no need to update because this trxn is consider similar to LOADING trxn
-        if (refOrder instanceof VasOrder) {
-          await this.transactionInventory(
-            newParentInventory,
-            refOrder,
-            -targetVas.qty,
-            -targetVas.uomValue,
-            INVENTORY_TRANSACTION_TYPE.UNPACKED
-          )
-        } else if (refOrder instanceof ReleaseGood) {
-          await generateInventoryHistory(
-            newParentInventory,
-            refOrder,
-            INVENTORY_TRANSACTION_TYPE.UNPACKED,
-            0,
-            0,
-            this.user,
-            this.trxMgr
-          )
+        if (targetVas.operationGuide && !issue) {
+          await this.doOperationTransaction(targetVas)
         }
 
-        // add TERMINATED status if inventory qty = 0
-        if (newParentInventory.qty === 0) {
-          newParentInventory.status = INVENTORY_STATUS.TERMINATED
-          await this.transactionInventory(newParentInventory, refOrder, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+        if (targetVas?.vas?.name.toUpperCase() === VAS.UNPACKING && !(refOrder instanceof ArrivalNotice)) {
+          // Update qty and uom value of parent inventory (only applies for pure vas and RO)
+          const parentInventory: Inventory = targetVas.inventory
+          let newParentInventory: Partial<Inventory> = Object.assign({}, parentInventory)
+          newParentInventory.qty = parentInventory.qty - targetVas.qty
+          newParentInventory.uomValue = Math.round((parentInventory.uomValue - targetVas.uomValue) * 100) / 100
+          newParentInventory.lockedQty = parentInventory.lockedQty - targetVas.qty
+          newParentInventory.lockedUomValue =
+            Math.round((parentInventory.lockedUomValue - targetVas.uomValue) * 100) / 100
+
+          // update qty and uomValue for VasOrder
+          // if refOrder is from ReleaseGood, no need to update because this trxn is consider similar to LOADING trxn
+          if (refOrder instanceof VasOrder) {
+            await this.transactionInventory(
+              newParentInventory,
+              refOrder,
+              -targetVas.qty,
+              -targetVas.uomValue,
+              INVENTORY_TRANSACTION_TYPE.UNPACKED
+            )
+          } else if (refOrder instanceof ReleaseGood) {
+            await generateInventoryHistory(
+              newParentInventory,
+              refOrder,
+              INVENTORY_TRANSACTION_TYPE.UNPACKED,
+              0,
+              0,
+              this.user,
+              this.trxMgr
+            )
+          }
+
+          // add TERMINATED status if inventory qty = 0
+          if (newParentInventory.qty === 0) {
+            newParentInventory.status = INVENTORY_STATUS.TERMINATED
+            await this.transactionInventory(newParentInventory, refOrder, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+          }
         }
       }
     }
@@ -812,7 +829,180 @@ export class VasWorksheetController extends WorksheetController {
         ? ORDER_STATUS.LOADING
         : ORDER_STATUS.DONE
 
+    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+      domain: domain.id,
+      name: orderNo
+    })
+
+    let qbOrderVas = await getRepository(OrderVas).createQueryBuilder('ov')
+    qbOrderVas
+      .leftJoinAndSelect(OrderInventory, 'oi', 'oi.release_good_id = ov.release_good_id')
+      .leftJoinAndSelect('ov.releaseGood', 'releaseGood')
+      .leftJoinAndSelect('ov.product', 'product')
+      .leftJoinAndSelect('ov.productDetail', 'productDetail')
+      .leftJoinAndSelect('ov.newProduct', 'newProduct')
+      .leftJoinAndSelect('ov.newProductDetail', 'newProductDetail')
+      .andWhere('ov.domain_id = :domain')
+      .andWhere('ov.release_good_id = :releaseGood')
+      .andWhere('ov.new_product_id notnull')
+      .andWhere('ov.new_product_detail_id notnull')
+      .setParameters({ domain: domain.id, releaseGood: releaseGood.id })
+
+    const orderVasWithNewSku: OrderVas[] = await qbOrderVas.getMany()
+
+    // .find({
+    //   domain,
+    //   releaseGood,
+    //   newTargetProduct: Not(IsNull()),
+    //   newTargetProductDetail: Not(IsNull())
+    // })
+
+    if (orderVasWithNewSku.length > 0) {
+      // const productId = orderVasWithNewSku.map(ov => {
+      //   return ov.product.id
+      // })
+
+      let qbOrderInventories = await getRepository(OrderInventory)
+        .createQueryBuilder('oi')
+        .leftJoinAndSelect('oi.product', 'product')
+        .leftJoinAndSelect('oi.productDetail', 'productDetail')
+        .leftJoinAndSelect('oi.domain', 'domain')
+        .leftJoinAndSelect('oi.bizplace', 'bizplace')
+        .leftJoinAndSelect('oi.releaseGood', 'releaseGood')
+        .leftJoinAndSelect('oi.inventory', 'inventory')
+        .leftJoinAndSelect('oi.orderProduct', 'orderProduct')
+        .andWhere('oi.domain_id = :domain')
+        .andWhere('oi.product_id IN (:...productId)')
+        // .andWhere('inventory.batch_id IN (:...batchId)')
+        .andWhere('oi.release_good_id = :releaseGood')
+        .setParameters({
+          domain: domain.id,
+          productId: orderVasWithNewSku.map(ov => {
+            return ov.product.id
+          }),
+          // batchId: orderVasWithNewSku.map(ov => {
+          //   return ov.batchId
+          // }),
+          releaseGood: releaseGood.id
+        })
+
+      let orderInventoryOrderVas: OrderInventory[] = await qbOrderInventories.getMany()
+
+      let updateOrderInventory: OrderInventory[] = []
+
+      let orderInventory: OrderInventory = {}
+
+      let saveOrderInventory: OrderInventory[] = []
+
+      // for saving oi
+      let newTargetInventory: OrderInventory = new OrderInventory()
+
+      let newOi: OrderInventory
+      // fix inventory
+      orderVasWithNewSku.forEach(ov => {
+        orderInventory = orderInventoryOrderVas.filter(oi => {
+          if (oi.product.id == ov.product.id && oi.releaseQty > 0 && oi.batchId == ov.batchId) {
+            if (oi.batchId == ov.batchId) {
+              return oi
+            }
+          }
+        })
+        let qtyVas: number = ov.qty
+
+        try {
+          for (let i = 0; qtyVas !== 0; i++) {
+            const oi = orderInventory[i]
+            //update old OI
+            const updatedReleaseQty: number = qtyVas <= oi.releaseQty ? oi.releaseQty - qtyVas : 0
+            const updatedReleaseUomValue: number = parseFloat(
+              (updatedReleaseQty * (oi.releaseUomValue / oi.releaseQty)).toFixed(2)
+            )
+            updateOrderInventory = {
+              ...oi,
+              releaseQty: updatedReleaseQty,
+              pickedQty: oi.pickedQty,
+              status: updatedReleaseQty == 0 ? ORDER_INVENTORY_STATUS.TERMINATED : oi.status,
+              releaseUomValue: updatedReleaseUomValue,
+              updater: user,
+              updatedAt: new Date()
+              // cuFlag: 'M'
+            }
+
+            saveOrderInventory.push(updateOrderInventory)
+
+            // Duplicate oi for newSKU =
+            // new OrderInventory()
+            const newOiReleaseQty: number = qtyVas <= oi.releaseQty ? qtyVas : oi.releaseQty
+            //can delete
+            // const newOiReleaseUomValue: number = parseFloat((newOiReleaseQty * (ov.newUomValue / ov.qty)).toFixed(2))
+
+            newOi = {
+              ...oi,
+              id: uuidv4(),
+              name: uuidv4(),
+              // domain: orderInventory.domain,
+              // bizplace: orderInventory.bizplace,
+              // releaseGood: orderInventory.releaseGood,
+              // inventory: orderInventory.inventory,
+              orderProduct: null,
+              // status: orderInventory.status, // can remove
+              batchId: newOi ? `${newOi.batchId} , ${oi.batchId}` : oi.batchId,
+              type: ORDER_TYPES.VAS_ORDER,
+              status: ORDER_INVENTORY_STATUS.LOADING,
+              releaseQty: ov.outputQty,
+              pickedQty: 0,
+              packingType: ov.newPackingType,
+              packingSize: ov.newProductDetail.packingSize,
+              uom: ov.newUom,
+              releaseUomValue: ov.newUomValue,
+              product: ov.newProduct,
+              productId: ov.newProduct.id,
+              productDetail: ov.newProductDetail,
+              creator: user,
+              updater: user,
+              createdAt: new Date(),
+              updatedAt: new Date()
+              // cuFlag: '+'
+            }
+            qtyVas = qtyVas - newOiReleaseQty
+            newTargetInventory = newOi
+          }
+          saveOrderInventory.push(newTargetInventory)
+        } catch (e) {
+          console.log(e)
+        }
+      })
+      await tx.getRepository(OrderInventory).save(saveOrderInventory)
+      // await tx.getRepository(OrderInventory).save(updateOrderInventory)
+      // .update({ id: orderInventory.id }, updateOrderInventory)
+    }
+
+    let orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
+      where: { domain: domain.id, releaseGood: releaseGood.id, status: Not(In([ORDER_INVENTORY_STATUS.TERMINATED])) }
+      // relations: ['product', 'productDetail', 'domain', 'bizplace', 'releaseGood', 'inventory', 'orderProduct']
+    })
+
+    // complete VAS worksheet
     worksheet = await this.completeWorksheet(worksheet, orderStatus)
+
+    //generate and activate loading worksheet
+    if (releaseGood) {
+      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      let loadingWorksheet = await this.generateWorksheet(
+        WORKSHEET_TYPE.LOADING,
+        releaseGood,
+        orderInventories,
+        ORDER_STATUS.LOADING,
+        ORDER_INVENTORY_STATUS.LOADING
+      )
+      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+      // here
+      // const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      // const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      // await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
+    }
+
     return worksheet
   }
 

package/server/controllers/worksheet-controller.ts

@@ -416,7 +416,7 @@ export class WorksheetController {
     let existingWorksheet: Worksheet
     try {
       existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
-    } catch (e) { }
+    } catch (e) {}
 
     if (existingWorksheet)
       throw new Error(
@@ -821,15 +821,26 @@ export class WorksheetController {
       worksheetType === WORKSHEET_TYPE.PICKING_REPLENISHMENT ||
       worksheetType === WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
     ) {
-      let targetInventories: OrderInventory[] = worksheet.worksheetDetails
-        .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
-        .map((wsd: WorksheetDetail) => {
-          let targetInventory: OrderInventory = wsd.targetInventory
-          targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
-          targetInventory.updater = this.user
-          return targetInventory
-        })
-
+      let targetInventories: OrderInventory[] = []
+      if (updatedRefOrderStatus == 'VAS') {
+        targetInventories = worksheet.worksheetDetails
+          .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
+          .map((wsd: WorksheetDetail) => {
+            let targetInventory: OrderInventory = wsd.targetInventory
+            targetInventory.status = updatedRefOrderStatus
+            targetInventory.updater = this.user
+            return targetInventory
+          })
+      } else {
+        targetInventories = worksheet.worksheetDetails
+          .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
+          .map((wsd: WorksheetDetail) => {
+            let targetInventory: OrderInventory = wsd.targetInventory
+            targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+            targetInventory.updater = this.user
+            return targetInventory
+          })
+      }
       await this.updateOrderTargets(targetInventories)
     }
 

package/server/graphql/resolvers/worksheet/loading/loading.ts

@@ -16,10 +16,8 @@ export const loadingResolver = {
       { domain, name: releaseGoodNo },
       ['bizplace', 'deliverTo']
     )
-
     const loadingWorksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
     let targetInventories: OrderInventory[] = worksheetDetails.map(itm => itm.targetInventory)
-
     const bizplace: Bizplace = releaseGood.bizplace
     orderInfo = {
       ...orderInfo,