@things-factory/worksheet-base 4.1.38 → 4.2.0

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

@@ -1,6 +1,15 @@
+import { Equal, Not } from 'typeorm'
+
 import { Product, ProductDetail } from '@things-factory/product-base'
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
-import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
+import {
+  Inventory,
+  INVENTORY_ITEM_SOURCE,
+  INVENTORY_STATUS,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  InventoryNoGenerator
+} from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
@@ -70,7 +79,7 @@ export class PackingWorksheetController extends VasWorksheetController {
     return worksheet
   }
 
-  async packing(worksheetDetailName: string, packedQty: number): Promise<WorksheetDetail> {
+  async packing(worksheetDetailName: string, packedQty: number, serialNumber: string): Promise<WorksheetDetail> {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
       WORKSHEET_TYPE.PACKING,
@@ -81,11 +90,13 @@ export class PackingWorksheetController extends VasWorksheetController {
         'targetInventory',
         'targetInventory.releaseGood',
         'targetInventory.inventory',
-        'targetInventory.inventory.location'
+        'targetInventory.inventory.location',
+        'targetInventory.product'
       ]
     )
     const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
     let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    const product: Product = targetInventory.product
     let inventory: Inventory = targetInventory.inventory
     const pickedQty: number = targetInventory.releaseQty
 
@@ -93,19 +104,81 @@ export class PackingWorksheetController extends VasWorksheetController {
       throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
     }
 
-    targetInventory.packedQty = packedQty
-    targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
-    await this.updateOrderTargets([targetInventory])
+    // 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`))
+        }
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: this.domain, serialNumber: serialNumber, product },
+          relations: ['product', 'inventory']
+        })
 
-    await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+        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.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
+
+      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
+        })
+
+        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.updateOrderTargets([targetInventory])
 
-    worksheetDetail.status = WORKSHEET_STATUS.DONE
     worksheetDetail.updater = this.user
     worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
     return worksheetDetail
   }
 
-  async scanProductPacking(worksheetDetailName: string, productBarcode: string): Promise<WorksheetDetail> {
+  async scanProductPacking(
+    worksheetDetailName: string,
+    productBarcode: string,
+    serialNumber?: string
+  ): Promise<WorksheetDetail> {
     let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
       worksheetDetailName,
       WORKSHEET_TYPE.PACKING,
@@ -139,15 +212,59 @@ export class PackingWorksheetController extends VasWorksheetController {
       )
     if (!productDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
+    // 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`))
+        }
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr
+          .getRepository(InventoryItem)
+          .findOne({ where: { domain: this.domain, serialNumber: serialNumber, product } })
+
+        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.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.packedAt = new Date()
-    targetInventory.packedByUser = this.user;
+    targetInventory.packedByUser = this.user
 
-    let packedBy: string[] = targetInventory.packedBy ? (targetInventory.packedBy).split(',') : []
+    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(',')
@@ -161,6 +278,19 @@ export class PackingWorksheetController extends VasWorksheetController {
       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 } })
+
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
+          itm.status = INVENTORY_STATUS.PACKED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
     } else {
       await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
     }
@@ -181,10 +311,86 @@ 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 } })
+
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
+        itm.status = INVENTORY_STATUS.TERMINATED
+        itm.updater = this.user
+      })
+
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+    }
+
     let orderStatus: string
     if (releaseGood?.courierOption) orderStatus = ORDER_STATUS.DONE
     else orderStatus = ORDER_STATUS.LOADING
 
     return await this.completeWorksheet(worksheet, orderStatus)
   }
+
+  async undoSerialNumberPacking(worksheetDetailName: string, inventoryItemId: string): Promise<void> {
+    const worksheetDetail: WorksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).findOne({
+      where: { name: worksheetDetailName, domain: this.domain, status: Not(Equal(WORKSHEET_STATUS.DEACTIVATED)) },
+      relations: [
+        'worksheet',
+        'worksheet.releaseGood',
+        'targetInventory',
+        'targetInventory.product',
+        'targetInventory.inventory'
+      ]
+    })
+
+    let targetInventory: OrderInventory = worksheetDetail.targetInventory
+    let releaseGood: ReleaseGood = worksheetDetail.worksheet.releaseGood
+
+    if (
+      targetInventory.releaseQty == targetInventory.packedQty &&
+      targetInventory.status == ORDER_INVENTORY_STATUS.PACKED
+    ) {
+      targetInventory.status = INVENTORY_STATUS.PACKING
+
+      await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .update({ id: worksheetDetail.id }, { status: WORKSHEET_STATUS.EXECUTING })
+    }
+
+    let inventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: releaseGood.id } })
+
+    let removeInventoryItem: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .findOne({ where: { id: inventoryItemId } })
+
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
+        itm.status = INVENTORY_STATUS.PACKING
+        itm.updater = this.user
+      })
+
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+    }
+
+    if (removeInventoryItem.source == INVENTORY_ITEM_SOURCE.OUTBOUND) {
+      await this.trxMgr.getRepository(InventoryItem).delete(removeInventoryItem.id)
+    } else {
+      await this.trxMgr.getRepository(InventoryItem).update(
+        {
+          id: inventoryItemId
+        },
+        {
+          status: INVENTORY_STATUS.STORED,
+          outboundOrderId: null,
+          updater: this.user
+        }
+      )
+    }
+
+    targetInventory.packedQty--
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
 }

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

@@ -453,7 +453,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         )
 
         pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-        if (pickedQty > releaseQty) {
+        if (pickedQty + targetInventory.pickedQty > releaseQty) {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
         }
       } else if (!foundProductDetail) {
@@ -555,8 +555,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       //validation to prevent over release
       if (inventory.qty <= 0) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
 
-      if (inventory.palletId !== palletId /*&& !product?.isRequireSerialNumberScanningOutbound*/)
-        //to be changed
+      if (inventory.palletId !== palletId && !product?.isRequireSerialNumberScanningOutbound)
         throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
 
       if (product?.isRequireSerialNumberScanningOutbound) {
@@ -566,7 +565,8 @@ export class PickingWorksheetController extends VasWorksheetController {
 
         let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
           where: {
-            inventory
+            inventory,
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
           }
         })
 
@@ -580,13 +580,11 @@ export class PickingWorksheetController extends VasWorksheetController {
           .findOne({ where: { domain: this.domain, palletId }, relations: ['product'] })
 
         if (foundSerialNumber) {
-          if (
-            foundSerialNumber.status !== INVENTORY_STATUS.STORED ||
-            foundSerialNumber.outboundOrderId ||
-            foundSerialNumber.inventory !== inventory
-            /*to be changed for replacement && inventory.palletId == palletId*/
-          ) {
-            throw new Error('Inventory Item is not available')
+          if (foundSerialNumber.outboundOrderId) {
+            let releaseGood: ReleaseGood = await this.trxMgr
+              .getRepository(ReleaseGood)
+              .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
+            throw new Error(`Inventory Item is already picked in ${releaseGood.name}`)
           }
 
           foundSerialNumber.status = INVENTORY_STATUS.PICKING
@@ -603,12 +601,13 @@ export class PickingWorksheetController extends VasWorksheetController {
           inventoryItem.name = InventoryNoGenerator.inventoryItemName()
           inventoryItem.serialNumber = serialNumber
           inventoryItem.status = INVENTORY_STATUS.PICKING
+          inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
           inventoryItem.outboundOrderId = releaseGood.id
           inventoryItem.product = product
           inventoryItem.inventory = scannedPalletIdInventory
           inventoryItem.domain = this.domain
 
-          await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
         }
 
         if (inventory.palletId !== palletId) {
@@ -648,10 +647,10 @@ export class PickingWorksheetController extends VasWorksheetController {
         }
       }
 
-      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
-
       targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
+      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+
       const fromLocation: Location = targetInventory.inventory.location
       if (locationName) {
         const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
@@ -954,12 +953,12 @@ export class PickingWorksheetController extends VasWorksheetController {
     ])
     await this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
-    let InventoryItems: InventoryItem = await this.trxMgr
+    let inventoryItems: InventoryItem = await this.trxMgr
       .getRepository(InventoryItem)
       .find({ where: { outboundOrderId: releaseGood.id } })
 
-    if (InventoryItems.length > 0) {
-      InventoryItems.forEach((itm: InventoryItem) => {
+    if (inventoryItems.length > 0) {
+      inventoryItems.forEach((itm: InventoryItem) => {
         itm.status = INVENTORY_STATUS.TERMINATED
         itm.updater = this.user
       })
@@ -973,7 +972,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       //     this.transactionInventory(itm, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
       // })
 
-      await this.trxMgr.getRepository(InventoryItem).save(InventoryItems)
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
     }
 
     let orderStatus: string
@@ -1126,17 +1125,17 @@ export class PickingWorksheetController extends VasWorksheetController {
       worksheetDetail.updater = this.user
       await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
 
-      let InventoryItems: InventoryItem = await this.trxMgr
+      let inventoryItems: InventoryItem = await this.trxMgr
         .getRepository(InventoryItem)
         .find({ where: { outboundOrderId: releaseGood.id } })
 
-      if (InventoryItems.length > 0) {
-        InventoryItems.forEach((itm: InventoryItem) => {
+      if (inventoryItems.length > 0) {
+        inventoryItems.forEach((itm: InventoryItem) => {
           itm.status = INVENTORY_STATUS.PICKED
           itm.updater = this.user
         })
 
-        await this.trxMgr.getRepository(InventoryItem).save(InventoryItems)
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
       }
 
       if (leftQty === 0) {
@@ -1247,8 +1246,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           }
         )
       } else {
-        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
     } catch (e) {}
   }
@@ -1362,8 +1361,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           }
         )
       } else {
-        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
     } catch (e) {}
   }

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

@@ -1,6 +1,13 @@
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 import { Product, ProductDetail } from '@things-factory/product-base'
-import { Inventory, INVENTORY_TRANSACTION_TYPE } from '@things-factory/warehouse-base'
+import {
+  Inventory,
+  INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  INVENTORY_STATUS,
+  InventoryNoGenerator,
+  INVENTORY_ITEM_SOURCE
+} from '@things-factory/warehouse-base'
 import { ReleaseGood, OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS } from '@things-factory/sales-base'
 import { Worksheet, WorksheetDetail } from '../../entities'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -51,7 +58,12 @@ export class SortingWorksheetController extends VasWorksheetController {
     return await this.activateWorksheet(worksheet, worksheetDetails, sortingWorksheetDetails)
   }
 
-  async scanProductSorting(taskNo: string, releaseGoodNo: string, productBarcode: string): Promise<void> {
+  async scanProductSorting(
+    taskNo: string,
+    releaseGoodNo: string,
+    productBarcode: string,
+    serialNumber: string
+  ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
         domain: this.domain,
@@ -113,8 +125,53 @@ export class SortingWorksheetController extends VasWorksheetController {
             const releaseQty: number = matchingOI.releaseQty
             const inventory: Inventory = matchingOI.inventory
             const releaseGood: ReleaseGood = matchingOI.releaseGood
+            const product: Product = inventory.product
 
             if (releaseQty != matchingOI?.sortedQty && sortedQty == 1) {
+              // Serial Number scanning for batch picking
+              if (matchingOI?.refWorksheetId) {
+                if (product?.isRequireSerialNumberScanningOutbound) {
+                  if (!serialNumber || serialNumber == '') {
+                    throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('sorting', `require serial number`))
+                  }
+
+                  let foundSerialNumber: InventoryItem = await this.trxMgr
+                    .getRepository(InventoryItem)
+                    .findOne({ where: { domain: this.domain, serialNumber: serialNumber, product } })
+
+                  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/sorted in ${releaseGood.name}`)
+                    }
+
+                    foundSerialNumber.status = INVENTORY_STATUS.SORTING
+                    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.SORTING
+                    inventoryItem.outboundOrderId = releaseGood.id
+                    inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+                    inventoryItem.product = product
+                    inventoryItem.inventory = inventory
+                    inventoryItem.domain = this.domain
+
+                    await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+                  }
+                }
+              }
+
               matchingOI.sortedQty = Boolean(matchingOI?.sortedQty) ? matchingOI.sortedQty + sortedQty : sortedQty
               sortedQty -= 1
               if (matchingOI.sortedQty == releaseQty) {
@@ -128,6 +185,19 @@ export class SortingWorksheetController extends VasWorksheetController {
                 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 } })
+
+                if (inventoryItems.length > 0) {
+                  inventoryItems.forEach((itm: InventoryItem) => {
+                    itm.status = INVENTORY_STATUS.SORTED
+                    itm.updater = this.user
+                  })
+
+                  await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+                }
               } else if (matchingOI?.sortedQty > releaseQty) {
                 const product: Product = matchingOI.inventory.product
                 throw new Error(this.ERROR_MSG.ORDER_ITEM.EXCESS_QTY(product.sku, packingType, packingSize))
@@ -141,7 +211,13 @@ export class SortingWorksheetController extends VasWorksheetController {
     }
   }
 
-  async sortingProduct(taskNo: string, releaseGoodNo: string, productId: string, sortingQty: number): Promise<void> {
+  async sortingProduct(
+    taskNo: string,
+    releaseGoodNo: string,
+    productId: string,
+    sortingQty: number,
+    serialNumber: string
+  ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: {
         domain: this.domain,
@@ -180,14 +256,70 @@ export class SortingWorksheetController extends VasWorksheetController {
           const packingType: string = matchingOI.packingType
           const packingSize: number = matchingOI.packingSize
 
+          if (product?.isRequireSerialNumberScanningOutbound) {
+            if (!serialNumber || serialNumber == '') {
+              throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('sorting', `require serial number`))
+            }
+
+            let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+              where: { domain: this.domain, serialNumber: serialNumber, product },
+              relations: ['product', 'inventory']
+            })
+
+            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/sorted in ${releaseGood.name}`)
+              }
+
+              foundSerialNumber.status = INVENTORY_STATUS.SORTING
+              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.SORTING
+              inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
+              inventoryItem.outboundOrderId = releaseGood.id
+              inventoryItem.product = product
+              inventoryItem.inventory = inventory
+              inventoryItem.domain = this.domain
+
+              foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+            }
+          }
+
           if (releaseQty != matchingOI?.sortedQty && sortingQty != 0) {
-            matchingOI.sortedQty = releaseQty
+            if (product?.isRequireSerialNumberScanningOutbound) {
+              matchingOI.sortedQty += sortingQty
+            } else {
+              matchingOI.sortedQty = releaseQty
+            }
+
             sortingQty -= releaseQty
             if (matchingOI.sortedQty == releaseQty) {
               matchingOI.status = ORDER_INVENTORY_STATUS.SORTED
               await this.updateOrderTargets([matchingOI])
               await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.SORTING)
 
+              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
+                })
+
+                await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+              }
+
               let worksheetDetail: WorksheetDetail = worksheetDetails.find(
                 wsd => wsd.targetInventory.id === matchingOI.id
               )
@@ -220,6 +352,19 @@ export class SortingWorksheetController extends VasWorksheetController {
     releaseGood.updater = this.user
     await this.trxMgr.getRepository(ReleaseGood).save(releaseGood)
 
+    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.TERMINATED
+        itm.updater = this.user
+      })
+
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+    }
+
     return releaseGood
   }