@things-factory/worksheet-base 4.3.144 → 4.3.146

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

@@ -1,10 +1,18 @@
 import { Equal, Not } from 'typeorm'
 
 import { ApplicationType } from '@things-factory/auth-base'
-import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
-import { Product, ProductDetail, ProductBarcode } from '@things-factory/product-base'
 import { logger } from '@things-factory/env'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  OrderPackage,
+  OrderPackageItem,
+  OrderProduct,
+  ReleaseGood
+} from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import {
   Inventory,
@@ -129,252 +137,339 @@ export class PackingWorksheetController extends VasWorksheetController {
     return worksheet
   }
 
-  async packing(worksheetDetailName: string, packedQty: number, serialNumber: string): Promise<WorksheetDetail> {
-    let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-      worksheetDetailName,
-      WORKSHEET_TYPE.PACKING,
-      [
-        'worksheet',
-        'worksheet.bizplace',
-        'worksheet.bizplace.domain',
-        'targetInventory',
-        'targetInventory.releaseGood',
-        'targetInventory.inventory',
-        'targetInventory.inventory.location',
-        'targetInventory.product',
-        'targetInventory.productDetail'
+  async packing(orderPackageItemId: string, packedQty: number, serialNumber: string): Promise<any> {
+    let orderPackageItem: OrderPackageItem = await this.trxMgr.getRepository(OrderPackageItem).findOne({
+      where: { id: orderPackageItemId },
+      relations: [
+        'orderProduct',
+        'orderProduct.orderInventories',
+        'orderPackage',
+        'orderPackage.bizplace',
+        'orderPackage.bizplace.domain',
+        'orderPackage.releaseGood'
       ]
-    )
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    let inventory: Inventory = targetInventory.inventory
-    const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
-    const product: Product = targetInventory.product
-    const productDetail: ProductDetail = targetInventory.productDetail
-    const pickedQty: number = targetInventory.releaseQty
-
-    if (packedQty > pickedQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
-    }
+    })
 
-    // Serial Number scanning for batch picking
-    if (targetInventory?.refWorksheetId) {
-      if (product?.isRequireSerialNumberScanningOutbound) {
-        if (!serialNumber || serialNumber == '') {
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
-        }
+    const orderProduct: OrderProduct = orderPackageItem.orderProduct
+    const orderInventories: OrderInventory[] = orderProduct.orderInventories.filter(oi => oi.packedQty != oi.pickedQty)
 
-        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
-          where: { domain: this.domain, serialNumber: serialNumber, productDetail }
-        })
+    let remainingPackQty: number = packedQty
+    let qtyToPack: number = 0
+    for (let orderInventory of orderInventories) {
+      const remainPackedQty: number = orderInventory.pickedQty - orderInventory.packedQty
+      let worksheetDetail: WorksheetDetail = await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wd')
+        .innerJoinAndSelect('wd.bizplace', 'b')
+        .innerJoinAndSelect('wd.targetInventory', 'oi')
+        .innerJoinAndSelect('oi.releaseGood', 'rg')
+        .innerJoinAndSelect('oi.inventory', 'inv')
+        .innerJoinAndSelect('oi.product', 'prd')
+        .innerJoinAndSelect('oi.productDetail', 'pd')
+        .where('oi.id = :id', { id: orderInventory.id })
+        .andWhere('wd.type = :type', { type: WORKSHEET_TYPE.PACKING })
+        .getOne()
+
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let inventory: Inventory = targetInventory.inventory
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+      const product: Product = targetInventory.product
+      const productDetail: ProductDetail = targetInventory.productDetail
+      const pickedQty: number = targetInventory.releaseQty
+      if (remainPackedQty >= packedQty) {
+        qtyToPack = packedQty
+        remainingPackQty = 0
+      } else {
+        qtyToPack = remainPackedQty
+        remainingPackQty -= remainPackedQty
+      }
 
-        if (foundSerialNumber) {
-          if (foundSerialNumber.outboundOrderId) {
-            let releaseGood: ReleaseGood = await this.trxMgr
-              .getRepository(ReleaseGood)
-              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
-            throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
+      if (qtyToPack > pickedQty) {
+        throw new Error(
+          this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`)
+        )
+      }
+
+      // Serial Number scanning for batch picking
+      if (targetInventory?.refWorksheetId) {
+        if (product?.isRequireSerialNumberScanningOutbound) {
+          if (!serialNumber || serialNumber == '') {
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
           }
 
-          foundSerialNumber.status = INVENTORY_STATUS.PACKING
-          foundSerialNumber.updater = this.user
-          foundSerialNumber.outboundOrderId = releaseGood.id
-
-          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
-        } else {
-          let inventoryItem: InventoryItem = new InventoryItem()
-          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
-          inventoryItem.serialNumber = serialNumber
-          inventoryItem.status = INVENTORY_STATUS.PACKING
-          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
-          inventoryItem.outboundOrderId = releaseGood.id
-          inventoryItem.product = product
-          inventoryItem.productDetail = productDetail
-          inventoryItem.inventory = inventory
-          inventoryItem.domain = this.domain
-
-          foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+            where: { domain: this.domain, serialNumber: serialNumber, productDetail }
+          })
+
+          if (foundSerialNumber) {
+            if (foundSerialNumber.outboundOrderId) {
+              let releaseGood: ReleaseGood = await this.trxMgr
+                .getRepository(ReleaseGood)
+                .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+              throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
+            }
+
+            foundSerialNumber.status = INVENTORY_STATUS.PACKING
+            foundSerialNumber.updater = this.user
+            foundSerialNumber.outboundOrderId = releaseGood.id
+
+            await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+          } else {
+            let inventoryItem: InventoryItem = new InventoryItem()
+            inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+            inventoryItem.serialNumber = serialNumber
+            inventoryItem.status = INVENTORY_STATUS.PACKING
+            inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+            inventoryItem.outboundOrderId = releaseGood.id
+            inventoryItem.product = product
+            inventoryItem.productDetail = productDetail
+            inventoryItem.inventory = inventory
+            inventoryItem.domain = this.domain
+
+            foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          }
         }
       }
-    }
 
-    targetInventory.packedQty = Boolean(targetInventory.packedQty) ? targetInventory.packedQty + packedQty : packedQty
-    if (targetInventory.packedQty == targetInventory.releaseQty) {
-      targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
+      targetInventory.packedQty = Boolean(targetInventory.packedQty) ? targetInventory.packedQty + qtyToPack : qtyToPack
+      if (targetInventory.packedQty == targetInventory.releaseQty) {
+        targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
 
-      let inventoryItems: InventoryItem = await this.trxMgr
-        .getRepository(InventoryItem)
-        .find({ where: { outboundOrderId: releaseGood.id } })
+        let inventoryItems: InventoryItem = await this.trxMgr
+          .getRepository(InventoryItem)
+          .find({ where: { outboundOrderId: releaseGood.id } })
 
-      if (inventoryItems.length > 0) {
-        inventoryItems.forEach((itm: InventoryItem) => {
-          itm.status = INVENTORY_STATUS.PACKED
-          itm.updater = this.user
-        })
+        if (inventoryItems.length > 0) {
+          inventoryItems.forEach((itm: InventoryItem) => {
+            itm.status = INVENTORY_STATUS.PACKED
+            itm.updater = this.user
+          })
 
-        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+        }
+
+        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+
+        worksheetDetail.status = WORKSHEET_STATUS.DONE
       }
 
-      await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+      await this.updateOrderTargets([targetInventory])
+
+      worksheetDetail.updater = this.user
+      worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-      worksheetDetail.status = WORKSHEET_STATUS.DONE
+      if (!remainingPackQty) {
+        break
+      }
     }
 
-    await this.updateOrderTargets([targetInventory])
+    orderPackageItem.packedQty = Boolean(orderPackageItem?.packedQty)
+      ? orderPackageItem.packedQty + packedQty
+      : packedQty
 
-    worksheetDetail.updater = this.user
-    worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
-    return worksheetDetail
-  }
+    if (orderPackageItem.packedQty == orderPackageItem.releaseQty) {
+      orderPackageItem.status = ORDER_STATUS.DONE
+    }
 
-  async scanProductPacking(worksheetDetailName: string, productBarcode: string, serialNumber?: string): Promise<any> {
-    let worksheetDetail: WorksheetDetail = await this.trxMgr
-      .getRepository(WorksheetDetail)
-      .createQueryBuilder('wd')
-      .innerJoinAndSelect('wd.bizplace', 'b') //
-      .innerJoinAndSelect('wd.targetInventory', 'oi')
-      .innerJoinAndSelect('oi.releaseGood', 'rg')
-      .innerJoinAndSelect('oi.inventory', 'inv')
-      .leftJoinAndSelect('oi.orderProduct', 'op')
-      .innerJoinAndSelect('oi.product', 'prd')
-      .innerJoinAndSelect('oi.productDetail', 'pd')
-      .innerJoinAndSelect('pd.productBarcodes', 'pb')
-      .where('wd.id = :id', { id: worksheetDetailName })
-      .getOne()
+    await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItem)
 
-    let targetInventory: OrderInventory = worksheetDetail.targetInventory
-    let inventory: Inventory = targetInventory.inventory
-    let packedQty: number = 1
-    let pickedQty: number = targetInventory.releaseQty
-    const releaseGood: ReleaseGood = targetInventory.releaseGood
-    const product: Product = targetInventory.product
-    const productDetail: ProductDetail = targetInventory.productDetail
-    const productBarcodes: [ProductBarcode] = productDetail.productBarcodes
-    let matchingProduct
-
-    if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
-      throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+    return {
+      releaseGood: orderPackageItem.orderPackage.releaseGood,
+      bizplace: orderPackageItem.orderPackage.bizplace,
+      bizplaceDomain: orderPackageItem.orderPackage.bizplace.domain
     }
+  }
 
-    matchingProduct = await this.getDirectQty(
-      {
-        ...productDetail,
-        product: targetInventory?.product
-      },
-      productBarcode,
-      packedQty
-    )
+  async scanProductPacking(orderPackageItemId: string, productBarcode: string, serialNumber?: string): Promise<any> {
+    let orderPackageItem: OrderPackageItem = await this.trxMgr.getRepository(OrderPackageItem).findOne({
+      where: { id: orderPackageItemId },
+      relations: ['orderPackage', 'orderProduct', 'orderProduct.orderInventories']
+    })
 
-    //validate matching product details based on scanned barcode
-    if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+    const orderProduct: OrderProduct = orderPackageItem.orderProduct
+    const orderInventories: OrderInventory[] = orderProduct.orderInventories.filter(oi => oi.packedQty != oi.pickedQty)
+    let packedQty: number = 1
 
-    packedQty = matchingProduct.qty
+    for (let orderInventory of orderInventories) {
+      let worksheetDetail: WorksheetDetail = await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wd')
+        .innerJoinAndSelect('wd.bizplace', 'b')
+        .innerJoinAndSelect('wd.targetInventory', 'oi')
+        .innerJoinAndSelect('oi.releaseGood', 'rg')
+        .innerJoinAndSelect('oi.inventory', 'inv')
+        .leftJoinAndSelect('oi.orderProduct', 'op')
+        .innerJoinAndSelect('oi.product', 'prd')
+        .innerJoinAndSelect('oi.productDetail', 'pd')
+        .innerJoinAndSelect('pd.productBarcodes', 'pb')
+        .where('oi.id = :id', { id: orderInventory.id })
+        .getOne()
+
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+
+      let inventory: Inventory = targetInventory.inventory
+      let pickedQty: number = targetInventory.releaseQty
+      const releaseGood: ReleaseGood = targetInventory.releaseGood
+      const product: Product = targetInventory.product
+      const productDetail: ProductDetail = targetInventory.productDetail
+      const productBarcodes: [ProductBarcode] = productDetail.productBarcodes
+      let matchingProduct
+
+      if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      }
 
-    if (packedQty + targetInventory.packedQty > pickedQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
-    }
+      matchingProduct = await this.getDirectQty(
+        {
+          ...productDetail,
+          product: targetInventory?.product
+        },
+        productBarcode,
+        packedQty
+      )
 
-    // Serial Number scanning for batch picking
-    if (targetInventory?.refWorksheetId) {
-      if (product?.isRequireSerialNumberScanningOutbound) {
-        if (!serialNumber || serialNumber == '') {
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
-        }
+      //validate matching product details based on scanned barcode
+      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-        let foundSerialNumber: InventoryItem = await this.trxMgr
-          .getRepository(InventoryItem)
-          .findOne({ where: { domain: this.domain, serialNumber: serialNumber, productDetail } })
+      packedQty = matchingProduct.qty
 
-        if (foundSerialNumber) {
-          if (foundSerialNumber.inventoryId !== inventory.id) {
-            throw new Error('Serial Number scanned is in another inventory')
-          }
+      if (packedQty + targetInventory.packedQty > pickedQty) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+      }
 
-          if (foundSerialNumber.outboundOrderId) {
-            let releaseGood: ReleaseGood = await this.trxMgr
-              .getRepository(ReleaseGood)
-              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
-            throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
+      // Serial Number scanning for batch picking
+      if (targetInventory?.refWorksheetId) {
+        if (product?.isRequireSerialNumberScanningOutbound) {
+          if (!serialNumber || serialNumber == '') {
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
           }
 
-          foundSerialNumber.status = INVENTORY_STATUS.PACKING
-          foundSerialNumber.updater = this.user
-          foundSerialNumber.outboundOrderId = releaseGood.id
-
-          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
-        } else {
-          let inventoryItem: InventoryItem = new InventoryItem()
-          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
-          inventoryItem.serialNumber = serialNumber
-          inventoryItem.status = INVENTORY_STATUS.PACKING
-          inventoryItem.outboundOrderId = releaseGood.id
-          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
-          inventoryItem.product = product
-          inventoryItem.productDetail = productDetail
-          inventoryItem.inventory = inventory
-          inventoryItem.domain = this.domain
-
-          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          let foundSerialNumber: InventoryItem = await this.trxMgr
+            .getRepository(InventoryItem)
+            .findOne({ where: { domain: this.domain, serialNumber: serialNumber, productDetail } })
+
+          if (foundSerialNumber) {
+            if (foundSerialNumber.inventoryId !== inventory.id) {
+              throw new Error('Serial Number scanned is in another inventory')
+            }
+
+            if (foundSerialNumber.outboundOrderId) {
+              let releaseGood: ReleaseGood = await this.trxMgr
+                .getRepository(ReleaseGood)
+                .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+              throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
+            }
+
+            foundSerialNumber.status = INVENTORY_STATUS.PACKING
+            foundSerialNumber.updater = this.user
+            foundSerialNumber.outboundOrderId = releaseGood.id
+
+            await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+          } else {
+            let inventoryItem: InventoryItem = new InventoryItem()
+            inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+            inventoryItem.serialNumber = serialNumber
+            inventoryItem.status = INVENTORY_STATUS.PACKING
+            inventoryItem.outboundOrderId = releaseGood.id
+            inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+            inventoryItem.product = product
+            inventoryItem.productDetail = productDetail
+            inventoryItem.inventory = inventory
+            inventoryItem.domain = this.domain
+
+            await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          }
         }
       }
-    }
 
-    targetInventory.packedQty = Boolean(targetInventory?.packedQty) ? targetInventory.packedQty + packedQty : packedQty
-    if (targetInventory.packedQty > pickedQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
-    }
+      targetInventory.packedQty = Boolean(targetInventory?.packedQty)
+        ? targetInventory.packedQty + packedQty
+        : packedQty
+      if (targetInventory.packedQty > pickedQty) {
+        throw new Error(
+          this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`)
+        )
+      }
 
-    targetInventory.packedAt = new Date()
-    targetInventory.packedByUser = this.user
+      targetInventory.packedAt = new Date()
+      targetInventory.packedByUser = this.user
 
-    let packedBy: string[] = targetInventory.packedBy ? targetInventory.packedBy.split(',') : []
-    if (!packedBy.find(x => x == this.user.name)) {
-      packedBy.push(this.user.name)
-      targetInventory.packedBy = packedBy.join(',')
-    }
+      let packedBy: string[] = targetInventory.packedBy ? targetInventory.packedBy.split(',') : []
+      if (!packedBy.find(x => x == this.user.name)) {
+        packedBy.push(this.user.name)
+        targetInventory.packedBy = packedBy.join(',')
+      }
 
-    if (targetInventory.packedQty == pickedQty) {
-      targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
-      await this.updateOrderTargets([targetInventory])
-      await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+      if (targetInventory.packedQty == pickedQty) {
+        targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
+        await this.updateOrderTargets([targetInventory])
+        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
 
-      worksheetDetail.status = WORKSHEET_STATUS.DONE
-      worksheetDetail.updater = this.user
-      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+        worksheetDetail.status = WORKSHEET_STATUS.DONE
+        worksheetDetail.updater = this.user
+        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-      let inventoryItems: InventoryItem = await this.trxMgr
-        .getRepository(InventoryItem)
-        .find({ where: { outboundOrderId: releaseGood.id } })
+        let inventoryItems: InventoryItem = await this.trxMgr
+          .getRepository(InventoryItem)
+          .find({ where: { outboundOrderId: releaseGood.id } })
 
-      if (inventoryItems.length > 0) {
-        inventoryItems.forEach((itm: InventoryItem) => {
-          itm.status = INVENTORY_STATUS.PACKED
-          itm.updater = this.user
-        })
+        if (inventoryItems.length > 0) {
+          inventoryItems.forEach((itm: InventoryItem) => {
+            itm.status = INVENTORY_STATUS.PACKED
+            itm.updater = this.user
+          })
 
-        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+        }
+      } else {
+        await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
       }
-    } else {
-      await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
+      break
     }
 
+    orderPackageItem.packedQty = Boolean(orderPackageItem?.packedQty)
+      ? orderPackageItem.packedQty + packedQty
+      : packedQty
+
+    if (orderPackageItem.packedQty == orderPackageItem.releaseQty) {
+      orderPackageItem.status = ORDER_STATUS.DONE
+    }
+
+    await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItem)
+    await this.trxMgr
+      .getRepository(OrderPackage)
+      .update({ id: orderPackageItem.orderPackage.id }, { updatedAt: new Date() })
+
     return {
       worksheetDetailInfos: [
         {
-          id: worksheetDetail.id,
-          releaseQty: worksheetDetail.targetInventory.releaseQty,
-          packedQty: worksheetDetail.targetInventory.packedQty,
-          status: worksheetDetail.status
+          id: orderPackageItem.id,
+          releaseQty: orderPackageItem.releaseQty,
+          packedQty: orderPackageItem.packedQty,
+          status: orderPackageItem.status
         }
       ]
     }
   }
 
-  async completePacking(releaseGoodNo: string): Promise<Worksheet> {
-    let releaseGood: ReleaseGood = await this.findRefOrder(ReleaseGood, {
-      domain: this.domain,
-      name: releaseGoodNo,
-      status: ORDER_STATUS.PACKING
-    })
+  async completePacking(releaseGoodNo: string, orderPackageId: string): Promise<Worksheet> {
+    let orderPackage: OrderPackage = await this.trxMgr
+      .getRepository(OrderPackage)
+      .findOne({ where: { id: orderPackageId } })
+
+    await this.trxMgr
+      .getRepository(OrderPackage)
+      .update({ id: orderPackage.id }, { status: ORDER_STATUS.DONE, updater: this.user, updatedAt: new Date() })
+
+    let releaseGood: ReleaseGood = await this.findRefOrder(
+      ReleaseGood,
+      {
+        domain: this.domain,
+        name: releaseGoodNo,
+        status: ORDER_STATUS.PACKING
+      },
+      ['bizplace']
+    )
 
     const worksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PACKING, [
       'worksheetDetails',
@@ -382,24 +477,32 @@ export class PackingWorksheetController extends VasWorksheetController {
     ])
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
-    let inventoryItems: InventoryItem = await this.trxMgr
-      .getRepository(InventoryItem)
-      .find({ where: { outboundOrderId: releaseGood.id } })
+    let orderPackages: OrderPackage[] = await this.trxMgr
+      .getRepository(OrderPackage)
+      .find({ where: { releaseGood, domain: this.domain, bizplace: releaseGood.bizplace } })
 
-    if (inventoryItems.length > 0) {
-      inventoryItems.forEach((itm: InventoryItem) => {
-        itm.status = INVENTORY_STATUS.TERMINATED
-        itm.updater = this.user
-      })
+    if (orderPackages.every(op => op.status == ORDER_STATUS.DONE)) {
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
 
-      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-    }
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.TERMINATED
+          itm.updater = this.user
+        })
 
-    let orderStatus: string
-    if (releaseGood?.courierOption) orderStatus = ORDER_STATUS.DONE
-    else orderStatus = ORDER_STATUS.LOADING
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
 
-    return await this.completeWorksheet(worksheet, orderStatus)
+      let orderStatus: string
+      if (releaseGood?.courierOption) orderStatus = ORDER_STATUS.DONE
+      else orderStatus = ORDER_STATUS.LOADING
+
+      return await this.completeWorksheet(worksheet, orderStatus)
+    } else {
+      return worksheet
+    }
   }
 
   async undoSerialNumberPacking(worksheetDetailName: string, inventoryItemId: string): Promise<void> {

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

@@ -12,9 +12,9 @@ import { XilnexController } from '../../../../controllers/pos'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 
 export const completePackingResolver = {
-  async completePacking(_: any, { releaseGoodNo }, context: any) {
+  async completePacking(_: any, { releaseGoodNo, orderPackageId }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await completePacking(tx, domain, user, releaseGoodNo)
+    await completePacking(tx, domain, user, releaseGoodNo, orderPackageId)
 
     const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
       where: { name: releaseGoodNo, domain },
@@ -51,8 +51,9 @@ export async function completePacking(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  releaseGoodNo: string
+  releaseGoodNo: string,
+  orderPackageId: string
 ): Promise<void> {
   const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  await packingWSCtrl.completePacking(releaseGoodNo)
+  await packingWSCtrl.completePacking(releaseGoodNo, orderPackageId)
 }