@things-factory/worksheet-base 5.0.0-alpha.5 → 5.0.0-alpha.52

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

@@ -1,23 +1,33 @@
-import { In } from 'typeorm'
+import { Equal, In, IsNull, Not } from 'typeorm'
 
 import { Bizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
   ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
   ORDER_STATUS,
   OrderInventory,
   OrderNoGenerator,
+  OrderProduct,
+  OrderTote,
+  OrderToteItem,
+  OrderToteSeal,
   OrderVas,
   ReleaseGood
 } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import {
   Inventory,
+  INVENTORY_ITEM_SOURCE,
   INVENTORY_STATUS,
   INVENTORY_TRANSACTION_TYPE,
+  InventoryItem,
+  InventoryNoGenerator,
   Location,
-  LOCATION_TYPE
+  LOCATION_TYPE,
+  Tote,
+  TOTE_STATUS
 } from '@things-factory/warehouse-base'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -335,7 +345,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       'worksheetDetails',
       'worksheetDetails.targetInventory',
       'worksheetDetails.targetInventory.inventory',
-      'worksheetDetails.targetInventory.product'
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.orderProduct'
     ])
 
     const worksheetDetails: WorksheetDetail[] = await this.extractMatchedWorksheetDetails(
@@ -344,7 +355,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       productId,
       packingType,
       packingSize,
-      ['targetInventory', 'targetInventory.inventory']
+      ['targetInventory', 'targetInventory.inventory', 'targetInventory.orderProduct']
     )
 
     let worksheetDetailIds: string[] = []
@@ -361,6 +372,13 @@ export class PickingWorksheetController extends VasWorksheetController {
       inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
       inventory.lockedUomValue = inventory.lockedUomValue - targetInventory.releaseUomValue
       await this.updateInventory(inventory)
+
+      await this.trxMgr
+        .getRepository(OrderProduct)
+        .update(
+          { id: targetInventory.orderProduct.id },
+          { status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN, updater: this.user }
+        )
     }
 
     await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetailIds)
@@ -385,7 +403,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     productBarcode: string,
     cartonId: string,
     binLocation?: string,
-    serialNumber?: string
+    serialNumber?: string,
+    toteNo?: string
   ): Promise<OrderInventory> {
     try {
       let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
@@ -398,6 +417,7 @@ export class PickingWorksheetController extends VasWorksheetController {
           'targetInventory.releaseGood',
           'targetInventory.inventory',
           'targetInventory.product',
+          'targetInventory.orderProduct',
           'targetInventory.product.productDetails',
           'targetInventory.product.productDetails.product',
           'targetInventory.product.productDetails.childProductDetail'
@@ -406,8 +426,10 @@ export class PickingWorksheetController extends VasWorksheetController {
 
       const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let targetProduct: OrderProduct = targetInventory.orderProduct
       const product: Product = targetInventory.product
       let inventory: Inventory = targetInventory.inventory
+      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
 
       //validation to prevent duplicated picking
       let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
@@ -443,29 +465,76 @@ export class PickingWorksheetController extends VasWorksheetController {
           detail.product?.id === product.id
       )
 
-      if (!foundProductDetail) {
+      if (!foundProductDetail && !product?.isRequireSerialNumberScanningOutbound) {
         const roProductDetail: ProductDetail = productDetails.find(
           (parentDetail: ProductDetail) =>
             parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
         )
 
         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) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
       }
 
-      if (product?.isRequireSerialNumberScanning) {
-        if (!serialNumber || serialNumber == '')
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
 
-        if (serialNumber) {
-          targetInventory.serialNumber = JSON.stringify(
-            targetInventory.serialNumber ? [...JSON.parse(targetInventory.serialNumber), serialNumber] : [serialNumber]
-          )
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory,
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
+          }
+        })
+
+        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 in ${releaseGood.name}`)
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKING
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = releaseGood.id
+
+          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+        } else {
+          if (totalInventoryItems >= inventory.qty) {
+            throw new Error('Insufficient inventory quantity to scan new serial number')
+          }
+
+          let inventoryItem: InventoryItem = new InventoryItem()
+          inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+          inventoryItem.serialNumber = serialNumber
+          inventoryItem.status = INVENTORY_STATUS.PICKING
+          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)
         }
       }
 
+      if (toteNo) {
+        await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace)
+      }
+
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
     } catch (error) {
       throw error
@@ -479,7 +548,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     locationName: string,
     pickedQty: number,
     binLocation?: string,
-    serialNumber?: string
+    serialNumber?: string,
+    toteNo?: string
   ): Promise<void> {
     try {
       let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
@@ -487,8 +557,10 @@ export class PickingWorksheetController extends VasWorksheetController {
         worksheetType,
         [
           'worksheet',
+          'worksheet.bizplace',
           'targetInventory',
           'targetInventory.releaseGood',
+          'targetInventory.orderProduct',
           'targetInventory.inventory',
           'targetInventory.inventory.location',
           'targetInventory.product'
@@ -499,6 +571,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       let targetInventory: OrderInventory = worksheetDetail.targetInventory
       const product: Product = targetInventory.product
       let inventory: Inventory = targetInventory.inventory
+      let targetProduct: OrderProduct = targetInventory.orderProduct
+      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
 
       //validation to prevent duplicated picking
       let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
@@ -509,22 +583,104 @@ 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)
+      if (inventory.palletId !== palletId && !product?.isRequireSerialNumberScanningOutbound)
         throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
 
-      if (product?.isRequireSerialNumberScanning) {
-        if (!serialNumber || serialNumber == '')
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
           throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
 
-        if (serialNumber) {
-          targetInventory.serialNumber = JSON.stringify(
-            targetInventory.serialNumber ? [...JSON.parse(targetInventory.serialNumber), serialNumber] : [serialNumber]
-          )
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory,
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
+          }
+        })
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: this.domain, serialNumber: serialNumber, product },
+          relations: ['product', 'inventory']
+        })
+
+        let scannedPalletIdInventory: Inventory = await this.trxMgr
+          .getRepository(Inventory)
+          .findOne({ where: { domain: this.domain, palletId }, relations: ['product'] })
+
+        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 in ${releaseGood.name}`)
+          }
+
+          foundSerialNumber.status = INVENTORY_STATUS.PICKING
+          foundSerialNumber.updater = this.user
+          foundSerialNumber.outboundOrderId = releaseGood.id
+
+          await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
+        } else {
+          if (totalInventoryItems >= inventory.qty) {
+            throw new Error('Insufficient inventory quantity to scan new serial number')
+          }
+
+          let inventoryItem: InventoryItem = new InventoryItem()
+          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
+
+          foundSerialNumber = await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+        }
+
+        if (inventory.palletId !== palletId) {
+          let existingOrderInv = await this.trxMgr.getRepository(OrderInventory).findOne({
+            where: {
+              domain: this.domain,
+              inventory: scannedPalletIdInventory,
+              releaseGood: releaseGood
+            }
+          })
+
+          if (existingOrderInv) {
+            //if replacement order inventory already existed in worksheet detail
+            await this.serialNumberReplacementForExistingOrderInv(
+              existingOrderInv,
+              targetInventory,
+              worksheetDetail,
+              foundSerialNumber
+            )
+          } else if (
+            scannedPalletIdInventory.batchId == inventory.batchId &&
+            scannedPalletIdInventory.product.id == product.id &&
+            scannedPalletIdInventory.product.packingType == product.packingType
+          ) {
+            //if replacement order inventory does not exist
+            await this.serialNumberReplacement(
+              targetInventory,
+              scannedPalletIdInventory,
+              releaseGood,
+              product,
+              worksheetDetail,
+              foundSerialNumber
+            )
+          } else {
+            throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
+          }
         }
       }
 
       targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
 
+      if (toteNo) {
+        await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace)
+      }
+
       await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
 
       const fromLocation: Location = targetInventory.inventory.location
@@ -823,12 +979,42 @@ export class PickingWorksheetController extends VasWorksheetController {
       status: ORDER_STATUS.PICKING
     })
 
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood, closedDate: IsNull() } })
+
+    if (foundNotSealedOrderTote) {
+      throw new Error('Please seal the tote(s) before completing')
+    }
+
     let worksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
       'worksheetDetails',
       'worksheetDetails.targetInventory'
     ])
     await 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
+      })
+
+      // let inventoryLists = InventoryItems.filter(
+      //   (value, index, self) => index === self.findIndex(itm => itm.inventory.id === value.inventory.id)
+      // )
+
+      // inventoryLists.forEach((itm: Inventory) => {
+      //   if (itm.inventory.qty - itm.releaseQty == 0)
+      //     this.transactionInventory(itm, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+      // })
+
+      await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+    }
+
     let orderStatus: string
     if (releaseGood?.packingOption) {
       orderStatus = ORDER_STATUS.READY_TO_PACK
@@ -862,14 +1048,14 @@ export class PickingWorksheetController extends VasWorksheetController {
     worksheet.updater = this.user
     worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
 
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const worksheetDetails: any = worksheet.worksheetDetails.filter(wsD => wsD.status != 'MISSING')
     worksheetDetails.forEach((wsd: WorksheetDetail) => {
       wsd.status = WORKSHEET_STATUS.DONE
       wsd.updater = this.user
     })
     await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
 
-    const targetInventories: OrderInventory[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
+    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
       let targetInventory: OrderInventory = wsd.targetInventory
       targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
       targetInventory.updater = this.user
@@ -877,7 +1063,7 @@ export class PickingWorksheetController extends VasWorksheetController {
     })
     await this.updateOrderTargets(targetInventories)
 
-    const releaseGoods: ReleaseGood[] = worksheet.worksheetDetails.map((wsd: WorksheetDetail) => {
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map((wsd: WorksheetDetail) => {
       let releaseGood: ReleaseGood = wsd.targetInventory.releaseGood
 
       let orderStatus: string
@@ -962,6 +1148,9 @@ export class PickingWorksheetController extends VasWorksheetController {
       }
 
       orderInventory.status = ORDER_INVENTORY_STATUS.PICKED
+      orderInventory.pickedBy = this.user?.name
+      orderInventory.pickedByUser = this.user
+      orderInventory.pickedAt = new Date()
 
       inventory.qty -= orderInventory.releaseQty
       inventory.uomValue = Math.round((inventory.uomValue - orderInventory.releaseUomValue) * 100) / 100
@@ -979,6 +1168,19 @@ export class PickingWorksheetController extends VasWorksheetController {
       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.PICKED
+          itm.updater = this.user
+        })
+
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+      }
+
       if (leftQty === 0) {
         inventory.status = INVENTORY_STATUS.TERMINATED
         await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
@@ -989,4 +1191,431 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     return orderInventory
   }
+
+  private async serialNumberReplacementForExistingOrderInv(
+    existingOrderInv,
+    targetInventory,
+    worksheetDetail,
+    foundSerialNumber
+  ) {
+    try {
+      //1. update replacement inventory, order inventory, old inventory, old order inventory quantity
+      let newInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: existingOrderInv?.inventoryId } })
+
+      let newOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: existingOrderInv?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.id } })
+
+      //if replacement inventory quantity insufficient
+      if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+        newOrderInventory.releaseQty += newInventory.qty - newInventory.lockedQty
+        newOrderInventory.releaseUomValue += newInventory.uomValue - newInventory.lockedUomValue
+
+        oldOrderInventory.releaseQty -= newOrderInventory.releaseQty
+        oldOrderInventory.releaseUomValue -= newOrderInventory.releaseUomValue
+
+        oldInventory.lockedQty -= newOrderInventory.releaseQty
+        oldInventory.lockedUomValue -= newOrderInventory.releaseUomValue
+
+        newInventory.lockedQty = newInventory.qty
+        newInventory.lockedUomValue = newInventory.uomValue
+      } else {
+        newOrderInventory.releaseQty += targetInventory.releaseQty - targetInventory.pickedQty
+        newOrderInventory.releaseUomValue +=
+          newOrderInventory.releaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        oldOrderInventory.releaseQty = targetInventory.pickedQty
+        oldOrderInventory.status = ORDER_INVENTORY_STATUS.PICKED
+        oldOrderInventory.releaseUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty
+
+        oldInventory.lockedQty -= targetInventory.releaseQty - targetInventory.pickedQty
+        oldInventory.lockedUomValue =
+          oldInventory.lockedQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty)
+        newInventory.lockedUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty
+      }
+
+      newInventory = await this.trxMgr.getRepository(Inventory).save({ ...newInventory, updater: this.user })
+
+      newOrderInventory = await this.trxMgr.getRepository(OrderInventory).save({
+        ...newOrderInventory,
+        status: INVENTORY_STATUS.PICKING,
+        pickedQty: existingOrderInv.pickedQty++,
+        updater: this.user
+      })
+
+      oldInventory = await this.trxMgr.getRepository(Inventory).save({ ...oldInventory, updater: this.user })
+
+      foundSerialNumber = await this.trxMgr
+        .getRepository(InventoryItem)
+        .save({ ...foundSerialNumber, inventory: newInventory })
+
+      //2. update replacement worksheet detail
+      await this.trxMgr.getRepository(WorksheetDetail).update(
+        {
+          targetInventory: existingOrderInv
+        },
+        {
+          status: WORKSHEET_STATUS.EXECUTING,
+          updater: this.user
+        }
+      )
+
+      if (oldOrderInventory.releaseQty !== 0) {
+        oldOrderInventory = await this.trxMgr
+          .getRepository(OrderInventory)
+          .save({ ...oldOrderInventory, updater: this.user })
+
+        await this.trxMgr.getRepository(WorksheetDetail).update(
+          {
+            name: worksheetDetail.name
+          },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user
+          }
+        )
+      } else {
+        await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+      }
+    } catch (e) {}
+  }
+
+  private async serialNumberReplacement(
+    targetInventory,
+    scannedPalletIdInventory,
+    releaseGood,
+    product,
+    worksheetDetail,
+    foundSerialNumber
+  ) {
+    try {
+      //1. create new inventory, new order inventory, update old inventory, old order inventory quantity
+      let newInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { id: scannedPalletIdInventory?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: this.domain, id: targetInventory?.id } })
+
+      let newOrderInventoryReleaseQty = 0
+      let newOrderInventoryReleaseUomValue = 0
+
+      //if replacement inventory quantity insufficient
+      if (newInventory.qty - newInventory.lockedQty < targetInventory.releaseQty - targetInventory.pickedQty) {
+        newOrderInventoryReleaseQty = newInventory.qty - newInventory.lockedQty
+        newOrderInventoryReleaseUomValue = newInventory.uomValue - newInventory.lockedUomValue
+
+        oldOrderInventory.releaseQty -= newOrderInventoryReleaseQty
+        oldOrderInventory.releaseUomValue -= newOrderInventoryReleaseUomValue
+
+        oldInventory.lockedQty -= newOrderInventoryReleaseQty
+        oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue
+
+        newInventory.lockedQty = newInventory.qty
+        newInventory.lockedUomValue = newInventory.uomValue
+      } else {
+        newOrderInventoryReleaseQty = targetInventory.releaseQty - targetInventory.pickedQty
+        newOrderInventoryReleaseUomValue =
+          newOrderInventoryReleaseQty * (targetInventory.releaseUomValue / targetInventory.releaseQty)
+
+        oldOrderInventory.releaseQty = targetInventory.pickedQty
+        oldOrderInventory.status = ORDER_INVENTORY_STATUS.PICKED
+        oldOrderInventory.releaseUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * oldOrderInventory.releaseQty
+
+        oldInventory.lockedQty -= newOrderInventoryReleaseQty
+        oldInventory.lockedUomValue -= newOrderInventoryReleaseUomValue
+
+        newInventory.lockedQty = newInventory.lockedQty + (targetInventory.releaseQty - targetInventory.pickedQty)
+        newInventory.lockedUomValue =
+          (targetInventory.releaseUomValue / targetInventory.releaseQty) * newInventory.lockedQty
+      }
+
+      newInventory = await this.trxMgr.getRepository(Inventory).save({ ...newInventory, updater: this.user })
+
+      let newTargetInventory = (({ id, ...targetInventory }) => targetInventory)(targetInventory)
+
+      let newOrderInventory = await this.trxMgr.getRepository(OrderInventory).save({
+        ...newTargetInventory,
+        domain: this.domain,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood,
+        releaseQty: newOrderInventoryReleaseQty,
+        releaseUomValue: newOrderInventoryReleaseUomValue,
+        pickedQty: 1,
+        product,
+        inventory: scannedPalletIdInventory,
+        creator: this.user,
+        updater: this.user
+      })
+
+      oldInventory = await this.trxMgr.getRepository(Inventory).save({ ...oldInventory, updater: this.user })
+
+      foundSerialNumber = await this.trxMgr
+        .getRepository(InventoryItem)
+        .save({ ...foundSerialNumber, inventory: newInventory })
+
+      //3. create new worksheet detail
+      let NewWorksheetDetail = (({ id, ...worksheetDetail }) => worksheetDetail)(worksheetDetail)
+      await this.trxMgr.getRepository(WorksheetDetail).save({
+        ...NewWorksheetDetail,
+        domain: this.domain,
+        name: WorksheetNoGenerator.pickingDetail(),
+        targetInventory: newOrderInventory,
+        status: WORKSHEET_STATUS.EXECUTING,
+        creator: this.user,
+        updater: this.user
+      })
+
+      //if old order inventory release quantity is 0 then delete
+      if (oldOrderInventory.releaseQty !== 0) {
+        oldOrderInventory = await this.trxMgr
+          .getRepository(OrderInventory)
+          .save({ ...oldOrderInventory, updater: this.user })
+
+        //4. update old worksheet detail
+        worksheetDetail = await this.trxMgr.getRepository(WorksheetDetail).update(
+          {
+            name: worksheetDetail.name
+          },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user
+          }
+        )
+      } else {
+        await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
+        await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
+      }
+    } catch (e) {}
+  }
+
+  private async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {
+    //1. find tote
+    let foundTote: Tote = await this.trxMgr
+      .getRepository(Tote)
+      .findOne({ where: { bizplace, name: toteNo, deletedAt: IsNull() } })
+
+    if (foundTote?.status == TOTE_STATUS.DAMAGED || foundTote?.status == TOTE_STATUS.DISPATCHED) {
+      foundTote = null
+    }
+
+    //2. find order tote
+    let foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } })
+
+    //if order tote not found the create one, if tote not found means it's tote box
+    //create order tote item
+    if (!foundOrderTote) {
+      const orderTote = await this.trxMgr.getRepository(OrderTote).save({
+        name: toteNo,
+        domain: this.domain,
+        releaseGood,
+        tote: foundTote ? foundTote : null,
+        updater: this.user
+      })
+
+      const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+        domain: this.domain,
+        name: OrderNoGenerator.orderToteItem(),
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote,
+        qty: pickedQty,
+        updater: this.user
+      })
+    } else {
+      if (foundOrderTote.closedDate) {
+        throw new Error('Tote has been sealed, please try another tote!')
+      }
+
+      //if found order tote then check if order tote item exist
+      const foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOne({
+        domain: this.domain,
+        orderProduct: targetProduct,
+        orderInventory: targetInventory,
+        orderTote: foundOrderTote
+      })
+
+      //if not order tote item doesnt exist then create one
+      if (!foundOrderToteItem) {
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          domain: this.domain,
+          name: OrderNoGenerator.orderToteItem(),
+          orderProduct: targetProduct,
+          orderInventory: targetInventory,
+          orderTote: foundOrderTote,
+          qty: pickedQty,
+          updater: this.user
+        })
+      } else {
+        //if found order tote item found then add the quantity
+        const orderToteItem = await this.trxMgr.getRepository(OrderToteItem).save({
+          ...foundOrderToteItem,
+          qty: foundOrderToteItem.qty + pickedQty
+        })
+      }
+    }
+  }
+
+  async undoSerialNumberPicking(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.pickedQty &&
+      targetInventory.status == ORDER_INVENTORY_STATUS.PICKED
+    ) {
+      targetInventory.status = INVENTORY_STATUS.PICKING
+
+      await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .update({ id: worksheetDetail.id }, { status: WORKSHEET_STATUS.EXECUTING })
+
+      targetInventory.inventory.qty += targetInventory.releaseQty
+      targetInventory.inventory.uomValue =
+        Math.round((targetInventory.inventory.uomValue + targetInventory.releaseUomValue) * 100) / 100
+      targetInventory.inventory.lockedQty = targetInventory.inventory.lockedQty + targetInventory.releaseQty
+      targetInventory.inventory.lockedUomValue =
+        Math.round((targetInventory.inventory.lockedUomValue + targetInventory.releaseUomValue) * 100) / 100
+
+      await this.trxMgr.getRepository(Inventory).save(targetInventory.inventory)
+    }
+
+    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.PICKING
+        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.pickedQty--
+    targetInventory.updater = this.user
+    await this.updateOrderTargets([targetInventory])
+  }
+
+  async sealTote(sealNo: string, toteNo: string, orderNo: string): Promise<void> {
+    const checkDuplicateSeal = await this.trxMgr.getRepository(OrderToteSeal).findOne({
+      where: {
+        name: sealNo
+      }
+    })
+
+    if (checkDuplicateSeal) {
+      throw new Error('Seal has been scanned before')
+    }
+
+    const releaseGood: ReleaseGood = await this.trxMgr
+      .getRepository(ReleaseGood)
+      .findOne({ where: { domain: this.domain, name: orderNo }, relations: ['bizplace', 'bizplace.domain'] })
+
+    let sealNoSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: {
+        domain: releaseGood.bizplace.domain,
+        name: 'minimum-seal-number'
+      }
+    })
+
+    if (!sealNoSetting) {
+      sealNoSetting = await this.trxMgr.getRepository(Setting).findOne({
+        where: {
+          domain: this.domain,
+          name: 'minimum-seal-number'
+        }
+      })
+    }
+
+    const foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: this.domain, name: toteNo, releaseGood } })
+
+    if (!foundOrderTote) {
+      throw new Error('Tote not scanned under this order')
+    }
+
+    let totalOrderToteItems = await this.trxMgr.getRepository(OrderToteItem).count({
+      where: {
+        orderTote: foundOrderTote
+      }
+    })
+
+    if (totalOrderToteItems < 1) {
+      throw new Error('Tote carton is empty')
+    }
+
+    const newToteOrderSeal: OrderToteSeal = await this.trxMgr.getRepository(OrderToteSeal).save({
+      domain: this.domain,
+      name: sealNo,
+      orderTote: foundOrderTote,
+      updater: this.user
+    })
+
+    const totalSeal = await this.trxMgr.getRepository(OrderToteSeal).count({
+      orderTote: foundOrderTote
+    })
+
+    if (totalSeal >= parseInt(sealNoSetting?.value || 0)) {
+      await this.trxMgr.getRepository(OrderTote).save({
+        ...foundOrderTote,
+        closedDate: new Date()
+      })
+    }
+  }
 }