@things-factory/worksheet-base 4.3.238 → 4.3.241

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,

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

@@ -5,9 +5,9 @@ import { EntityManager } from 'typeorm'
 import { LoadingWorksheetController } from '../../../../controllers'
 
 export const undoLoadingResolver = {
-  async undoLoading(_: any, { deliveryOrder, palletIds }, context: any) {
+  async undoLoading(_: any, { deliveryOrder, palletIds, productIds }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await undoLoading(tx, domain, user, deliveryOrder, palletIds)
+    await undoLoading(tx, domain, user, deliveryOrder, palletIds, productIds)
   }
 }
 
@@ -16,8 +16,9 @@ export async function undoLoading(
   domain: Domain,
   user: User,
   deliveryOrder: Partial<DeliveryOrder>,
-  palletIds: string[]
+  palletIds: string[],
+  productIds: string[]
 ): Promise<void> {
   const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  await worksheetController.undoLoading(deliveryOrder, palletIds)
+  await worksheetController.undoLoading(deliveryOrder, palletIds, productIds)
 }

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

@@ -6,6 +6,7 @@ import {
   OrderInventory,
   ReleaseGood,
   OrderTote,
+  OrderVas,
   OrderToteItem
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
@@ -70,6 +71,7 @@ export const loadingWorksheetResolver = {
       },
       relations: [
         'targetInventory',
+        'targetInventory.product',
         'targetInventory.orderProduct',
         'targetInventory.inventory',
         'targetInventory.inventory.location',
@@ -111,6 +113,20 @@ export const loadingWorksheetResolver = {
       foundWSD.sort((a, b) => (a.toteName > b.toteName ? 1 : -1))
     }
 
+    let foundOV: OrderVas[] = await getRepository(OrderVas).find({
+      where: {
+        domain,
+        releaseGood: releaseGood,
+        status: Not(Equal(WORKSHEET_STATUS.DONE))
+      },
+      relations: ['newProduct', 'product', 'newProductDetail']
+    })
+
+    if (foundOV.length > 0) {
+      foundWSD = await insertVas(foundWSD, foundOV)
+      //   foundWSD = await formatLoadingDataVas(foundWSD)
+    }
+
     let worksheetDetailInfos = foundWSD
       .filter(itm => itm.targetInventory.releaseQty > 0)
       .map((loadingWSD: any) => {
@@ -121,7 +137,8 @@ export const loadingWorksheetResolver = {
           palletId: inventory.palletId,
           batchId: inventory.batchId,
           batchIdRef: inventory.batchIdRef,
-          product: inventory.product,
+          product: targetInventory.product,
+          pickedQty: targetInventory.pickedQty,
           releaseQty: targetInventory.releaseQty,
           releaseUomValue: targetInventory.releaseUomValue,
           status: loadingWSD.status,
@@ -130,7 +147,8 @@ export const loadingWorksheetResolver = {
           packingType: inventory.packingType,
           packingSize: inventory.packingSize,
           inventory: targetInventory.inventory,
-          toteName: loadingWSD.toteName
+          toteName: loadingWSD.toteName,
+          targetVas: loadingWSD.targetVas
         }
       })
 
@@ -146,3 +164,51 @@ export const loadingWorksheetResolver = {
     }
   }
 }
+
+export async function insertVas(wsd, ov) {
+  wsd = wsd.map(wd => {
+    for (let i = 0; i < ov.length; i++) {
+      // if (ov[i].newTargetProduct) {
+      if (wd.targetInventory.productId == ov[i].product.id && wd.targetInventory.batchId == ov[i].batchId) {
+        wd.targetVas = ov[i]
+      }
+      // }
+    }
+    return wd
+  })
+  return wsd
+  // }
+}
+
+// export async function formatLoadingDataVas(wsd) {
+//   let formattedData: WorksheetDetail[] = []
+//   formattedData = wsd.map(wd => {
+//     if (wd.targetVas) {
+//       if (wd.targetVas.newTargetProduct) {
+//         const newQty = wd.targetInventory.releaseQty - wd.targetVas.qty
+//         wd.targetInventory.releaseQty = newQty
+//         wd.targetInventory.pickedQty = newQty
+//         const newSku: WorksheetDetail = {
+//           ...wd,
+//           targetVas: null,
+//           targetInventory: {
+//             ...wd.targetInventory,
+//             releaseQty: wd.targetVas.outputQty,
+//             pickedQty: wd.targetVas.outputQty,
+//             inventory: { ...wd.targetInventory.inventory, product: wd.targetVas.newTargetProduct }
+//           }
+//         }
+//         wsd.push(newSku)
+//       }
+//     }
+//     return wd
+//   })
+
+//   formattedData = wsd.splice(wd => wd.targetInventory.pickedQty == 0)
+
+//   // formattedData = formattedData.sort((a, b) =>
+//   //   a.targetInventory.inventory.batchId > b ? 1 : a.targetVas && !b.targetVas ? -1 : a.targetVas && !b.targetVas ? 1 : 0
+//   // )
+
+//   return formattedData
+// }

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

@@ -43,7 +43,7 @@ export async function packing(
       break
 
     case ApplicationType.POWRUP:
-      const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true })
+      const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
       if (powrup) {
         const powrupCtrl: PowrupController = new PowrupController(tx, domain, user)

package/server/graphql/resolvers/worksheet/packing-worksheet.ts

@@ -212,7 +212,7 @@ export const packingWorksheetResolver = {
           break
 
         case ApplicationType.POWRUP:
-          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true })
+          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
           if (powrup) {
             // asynchronously get document from powrup

package/server/graphql/resolvers/worksheet/picking/complete-batch-picking.ts

@@ -134,7 +134,7 @@ export async function completeBatchPicking(
           break
 
         case ApplicationType.POWRUP:
-          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true })
+          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
           if (powrup) {
             const initPowrupShipment = async (powrup: Powrup, foundReleaseGood: ReleaseGood) => {

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -23,6 +23,7 @@ import {
   OrderPackage,
   OrderPackageItem,
   OrderProduct,
+  OrderVas,
   ReleaseGood,
   Replenishment
 } from '@things-factory/sales-base'
@@ -43,6 +44,7 @@ import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 import { createLmdParcel } from '../../../../utils'
+import { activateVas } from '../vas/activate-vas'
 
 export const completePickingResolver = {
   async completePicking(_: any, { releaseGoodNo }, context: any) {
@@ -156,7 +158,7 @@ export async function completePicking(
           break
 
         case ApplicationType.POWRUP:
-          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true })
+          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
           if (powrup) {
             const initPowrupShipment = async powrup => {
@@ -400,8 +402,25 @@ export async function completePicking(
           }
         })
 
+        let orderVas: OrderVas[] = await tx.getRepository(OrderVas).find({ where: { domain: domain, releaseGood } })
+        if (orderVas) {
+          try {
+            const vasWorksheet: Worksheet = await tx
+              .getRepository(Worksheet)
+              .findOne({ where: { releaseGood, type: WORKSHEET_TYPE.VAS } })
+
+            const vasWorksheetDetails: WorksheetDetail[] = await tx
+              .getRepository(WorksheetDetail)
+              .find({ where: { domain: domain, worksheet: vasWorksheet.id } })
+
+            if (vasWorksheet) {
+              await activateVas(tx, domain, user, vasWorksheet.name, vasWorksheetDetails)
+            }
+          } catch (e) { }
+        }
+        // Can improve by applying "Else" since if got VAS user has to complete then only we generate loading worksheet
         if (!existLoadingWorksheet && !releaseGood.courierOption && !releaseGood.packingOption) {
-          if (pickedTargetInventories.length > 0) {
+          if (pickedTargetInventories.length > 0 && orderVas.length == 0) {
             const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
             let loadingWorksheet: Worksheet = await loadingWSCtrl.generateLoadingWorksheet(
               releaseGoodNo,

package/server/graphql/resolvers/worksheet/vas/complete-vas.ts

@@ -1,7 +1,7 @@
 import { User } from '@things-factory/auth-base'
 import { ArrivalNotice, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+import { EntityManager, getRepository, In } from 'typeorm'
 import { WORKSHEET_TYPE } from '../../../../constants'
 import { LoadingWorksheetController, PutawayWorksheetController, VasWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
@@ -9,6 +9,24 @@ import { Worksheet, WorksheetDetail } from '../../../../entities'
 export const completeVasResolver = {
   async completeVas(_: any, { orderNo, orderType, worksheetDetails }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    if (!worksheetDetails) {
+      const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+        domain: domain.id,
+        name: orderNo
+      })
+      const worksheet: Worksheet[] = await getRepository(Worksheet).find({
+        domain: domain.id,
+        releaseGood: releaseGood.id,
+        type: WORKSHEET_TYPE.VAS
+      })
+      const worksheetId = worksheet.map(w => {
+        return w.id
+      })
+      worksheetDetails = await getRepository(WorksheetDetail).find({
+        domain: domain.id,
+        worksheet: In(worksheetId)
+      })
+    }
     await completeVAS(tx, domain, user, orderNo, orderType, worksheetDetails)
   }
 }
@@ -22,7 +40,14 @@ export async function completeVAS(
   worksheetDetails: WorksheetDetail[]
 ): Promise<Worksheet> {
   const worksheetController: VasWorksheetController = new VasWorksheetController(tx, domain, user)
-  let worksheet: Worksheet = await worksheetController.completeVAS(orderNo, orderType, worksheetDetails)
+  let worksheet: Worksheet = await worksheetController.completeVAS(
+    tx,
+    domain,
+    user,
+    orderNo,
+    orderType,
+    worksheetDetails
+  )
 
   // if (orderType === ORDER_TYPES.ARRIVAL_NOTICE) {
   //   if (!worksheet.worksheetDetails?.length || !worksheet.arrivalNotice?.id) {