@things-factory/worksheet-base 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,1769 @@
+import { EntityManager, Equal, getConnection, 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 {
+  //@ts-ignore
+  GenerateBatchPickInfo,
+  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,
+  Tote,
+  TOTE_STATUS
+} from '@things-factory/warehouse-base'
+
+import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
+import { Worksheet, WorksheetDetail } from '../../entities'
+import { generateInventoryHistory, WorksheetNoGenerator } from '../../utils'
+import { VasWorksheetController } from '../vas/vas-worksheet-controller'
+
+export class PickingWorksheetController extends VasWorksheetController {
+  async generatePickingWorksheet(releaseGoodNo: string, currentStatus: string = null): Promise<Worksheet> {
+    //@ts-ignore
+    let releaseGood: ReleaseGood = await this.findRefOrder(
+      //@ts-ignore
+      ReleaseGood,
+      {
+        domain: { id: this.domain.id },
+        name: releaseGoodNo,
+        status: ORDER_STATUS.PENDING_WORKSHEET
+      },
+      ['orderInventories', 'orderInventories.inventory', 'orderVass']
+    )
+    const orderInventories: OrderInventory[] = releaseGood.orderInventories
+    const orderVASs: OrderVas[] = releaseGood.orderVass
+
+    let worksheet: Worksheet = await this.createWorksheet(releaseGood, WORKSHEET_TYPE.PICKING)
+
+    if (orderInventories.every((oi: OrderInventory) => oi.inventory?.id) || releaseGood.crossDocking) {
+      worksheet.worksheetDetails = await this.createWorksheetDetails(
+        worksheet,
+        WORKSHEET_TYPE.PICKING,
+        orderInventories
+      )
+    }
+
+    orderInventories.forEach((oi: OrderInventory) => {
+      oi.status =
+        oi.crossDocking || oi.inventory?.id
+          ? ORDER_INVENTORY_STATUS.READY_TO_PICK
+          : ORDER_INVENTORY_STATUS.PENDING_SPLIT
+      oi.updater = this.user
+    })
+    await this.updateOrderTargets(orderInventories)
+
+    if (orderVASs?.length > 0) {
+      await this.generateVasWorksheet(releaseGood)
+    }
+
+    releaseGood.status = ORDER_STATUS.READY_TO_PICK
+    releaseGood.updater = this.user
+    await this.updateRefOrder(releaseGood, null, currentStatus)
+
+    return worksheet
+  }
+
+  async generateBatchPickingWorksheet(releaseGoodWithBiz: [GenerateBatchPickInfo[]]): Promise<Worksheet[]> {
+    let worksheets = []
+
+    for (let i = 0; i < releaseGoodWithBiz.length; i++) {
+      let releaseGoodNos = releaseGoodWithBiz[i].map(itm => itm.releaseGoodNo)
+
+      let releaseGoods: ReleaseGood[] = await this.trxMgr.getRepository(ReleaseGood).find({
+        where: { domain: { id: this.domain.id }, name: In(releaseGoodNos), status: ORDER_STATUS.PENDING_WORKSHEET },
+        relations: [
+          'orderProducts',
+          'orderProducts.product',
+          'orderInventories',
+          'orderInventories.inventory',
+          'bizplace',
+          'bizplace.domain'
+        ]
+      })
+
+      let orderInventories: OrderInventory[] = []
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        const foundOIs: OrderInventory[] = releaseGood.orderInventories
+        foundOIs.map((oi: OrderInventory) => {
+          orderInventories.push(oi)
+        })
+      })
+
+      const worksheetSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+        where: {
+          domain: { id: this.domain.id },
+          name: TASK_NUMBER_SETTING_KEY.TASK_NO_RULE
+        }
+      })
+      if (!worksheetSetting) throw new Error(this.ERROR_MSG.FIND.NO_RESULT('task number rule'))
+
+      let worksheet: Worksheet = new Worksheet()
+      worksheet.name = WorksheetNoGenerator.generate(WORKSHEET_TYPE.BATCH_PICKING)
+      worksheet.type = WORKSHEET_TYPE.BATCH_PICKING
+      worksheet.taskNo = await generateId({
+        domain: this.domain,
+        type: TASK_NUMBER_RULE_TYPE.TASK_NO,
+        seed: {}
+      })
+      worksheet.status = WORKSHEET_STATUS.DEACTIVATED
+      worksheet.bizplace = releaseGoodWithBiz[i][0].bizplaceId
+      worksheet.domain = this.domain
+      worksheet.creator = this.user
+      worksheet.updater = this.user
+      worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+      if (orderInventories.some((oi: OrderInventory) => oi.inventory?.id)) {
+        const hasInventoryOIs: OrderInventory[] = orderInventories.filter(
+          (orderInventory: OrderInventory) => orderInventory.inventory !== null
+        )
+
+        worksheet.worksheetDetails = await this.createWorksheetDetails(
+          worksheet,
+          WORKSHEET_TYPE.BATCH_PICKING,
+          hasInventoryOIs
+        )
+      }
+
+      orderInventories.forEach((oi: OrderInventory) => {
+        oi.refWorksheetId = worksheet.id
+        oi.status = oi.inventory?.id ? ORDER_INVENTORY_STATUS.READY_TO_PICK : ORDER_INVENTORY_STATUS.PENDING_SPLIT
+        oi.updater = this.user
+      })
+      await this.updateOrderTargets(orderInventories)
+
+      releaseGoods = releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          status: ORDER_STATUS.READY_TO_PICK,
+          updater: this.user
+        }
+      })
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
+
+      worksheets.push(worksheet)
+    }
+    return worksheets
+  }
+
+  async generateBatchPickingWorksheetDetail(
+    worksheet: Worksheet,
+    targetInventory: Partial<OrderInventory>[]
+  ): Promise<WorksheetDetail[]> {
+    // Create worksheet details
+    //@ts-ignore
+    return await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.BATCH_PICKING, [targetInventory])
+  }
+
+  async generatePickingWorksheetDetail(
+    worksheet: Worksheet,
+    targetInventory: Partial<OrderInventory>[]
+  ): Promise<WorksheetDetail[]> {
+    // Create worksheet details
+    //@ts-ignore
+    return await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.PICKING, [targetInventory])
+  }
+
+  async activatePicking(worksheetNo: string): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.PICKING, [
+      'releaseGood',
+      'releaseGood.bizplace',
+      'domain',
+      'bizplace',
+      'bizplace.domain',
+      'bizplace.company',
+      'bizplace.company.domain',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.product'
+    ])
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
+    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+      let targetInventory: OrderInventory = wsd.targetInventory
+      targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
+      targetInventory.updater = this.user
+      return targetInventory
+    })
+    this.updateOrderTargets(targetInventories)
+
+    let releaseGood: ReleaseGood = worksheet.releaseGood
+    releaseGood.status = ORDER_STATUS.PICKING
+    releaseGood.updater = this.user
+    this.updateRefOrder(releaseGood)
+
+    worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
+
+    try {
+      const vasWorksheet: Worksheet = await this.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.VAS)
+      if (vasWorksheet) {
+        await this.activateVAS(vasWorksheet.name, vasWorksheet.worksheetDetails)
+      }
+    } catch (e) {}
+
+    const pendingSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
+      where: {
+        domain: { id: this.domain.id },
+        releaseGood: { id: releaseGood.id },
+        status: ORDER_INVENTORY_STATUS.PENDING_SPLIT
+      }
+    })
+    if (pendingSplitOIs?.length) {
+      const ids: string[] = pendingSplitOIs.map((oi: OrderInventory) => oi.id)
+      await this.trxMgr.getRepository(OrderInventory).delete(ids)
+    }
+
+    return worksheet
+  }
+
+  async activateBatchPicking(worksheetNo: string): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.findActivatableWorksheet(worksheetNo, WORKSHEET_TYPE.BATCH_PICKING, [
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.releaseGood',
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.releaseGood.orderProducts',
+      'worksheetDetails.targetInventory.releaseGood.orderProducts.product',
+      'bizplace',
+      'bizplace.domain',
+      'bizplace.company',
+      'bizplace.company.domain'
+    ])
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails.filter(x => x.status == 'DEACTIVATED')
+    const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+      let targetInventory: OrderInventory = wsd.targetInventory
+      targetInventory.status = ORDER_INVENTORY_STATUS.PICKING
+      targetInventory.updater = this.user
+      return targetInventory
+    })
+    this.updateOrderTargets(targetInventories)
+
+    worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
+
+    // retrieve order inventory
+    const pickingOrderInventory: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
+      where: { domain: { id: this.domain.id }, refWorksheetId: worksheet.id, status: ORDER_STATUS.PICKING },
+      relations: ['releaseGood']
+    })
+
+    let releaseGoods: ReleaseGood[] = pickingOrderInventory.map((oi: OrderInventory) => oi.releaseGood)
+
+    if (releaseGoods?.length) {
+      releaseGoods = releaseGoods.map((rg: ReleaseGood) => {
+        return {
+          ...rg,
+          status: ORDER_STATUS.PICKING,
+          updater: this.user
+        }
+      })
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
+    }
+
+    return worksheet
+  }
+
+  async assignPickingInventories(
+    worksheetNo: string,
+    batchId: string,
+    productId: string,
+    packingType: string,
+    packingSize: number,
+    worksheetDetails: Partial<WorksheetDetail>[]
+  ): Promise<void> {
+    // 1. Remove prev worksheet details if it's exists
+    const worksheet: Worksheet = await this.findWorksheetByNo(worksheetNo, [
+      'bizplace',
+      'releaseGood',
+      'worksheetDetails'
+    ])
+    const releaseGood: ReleaseGood = worksheet.releaseGood
+    const bizplace: Bizplace = worksheet.bizplace
+    const prevWorksheetDetails: WorksheetDetail[] = await this.extractMatchedWorksheetDetails(
+      worksheet.worksheetDetails,
+      batchId,
+      productId,
+      packingType,
+      packingSize
+    )
+    // Delete order inventories
+    if (prevWorksheetDetails?.length) {
+      const worksheetDetailIds: string[] = prevWorksheetDetails.map((wsd: WorksheetDetail) => wsd.id)
+      const prevTargetInventoryIds: string[] = prevWorksheetDetails.map(
+        (wsd: WorksheetDetail) => wsd.targetInventory.id
+      )
+
+      await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetailIds)
+      await this.trxMgr.getRepository(OrderInventory).delete(prevTargetInventoryIds)
+    }
+
+    for (let worksheetDetail of worksheetDetails) {
+      if (worksheetDetail.targetInventory?.inventory?.id) {
+        worksheetDetail = await this.findWorksheetDetail(worksheetDetail, [
+          'targetInventory',
+          'targetInventory.inventory'
+        ])
+      }
+
+      const targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let inventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOneBy({ id: targetInventory.inventory.id })
+      const product: Product = await this.trxMgr.getRepository(Product).findOneBy({ id: productId })
+
+      // Create order inventories
+      let newTargetInventory: OrderInventory = Object.assign({}, targetInventory)
+      //@ts-ignore
+      delete newTargetInventory.id
+      newTargetInventory.domain = this.domain
+      newTargetInventory.bizplace = bizplace
+      newTargetInventory.name = OrderNoGenerator.orderInventory()
+      newTargetInventory.releaseGood = releaseGood
+      newTargetInventory.inventory = inventory
+      newTargetInventory.batchId = batchId
+      newTargetInventory.product = product
+      newTargetInventory.packingType = packingType
+      newTargetInventory.packingSize = packingSize
+      newTargetInventory.creator = this.user
+      newTargetInventory.updater = this.user
+      newTargetInventory = await this.trxMgr.getRepository(OrderInventory).save(newTargetInventory)
+
+      // Update locked qty and uomValue of inventory
+      inventory.lockedQty = targetInventory.releaseQty + (inventory.lockedQty || 0)
+      inventory.lockedUomValue = targetInventory.releaseUomValue + (inventory.lockedUomValue || 0)
+      await this.updateInventory(inventory)
+
+      // Create worksheet details
+      await this.createWorksheetDetails(worksheet, WORKSHEET_TYPE.PICKING, [newTargetInventory])
+    }
+  }
+
+  async undoPickingAssigment(
+    worksheetNo: string,
+    batchId: string,
+    productId: string,
+    packingType: string,
+    packingSize: number
+  ): Promise<void> {
+    const worksheet: Worksheet = await this.findWorksheetByNo(worksheetNo, [
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.inventory',
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.orderProduct'
+    ])
+
+    const worksheetDetails: WorksheetDetail[] = await this.extractMatchedWorksheetDetails(
+      worksheet.worksheetDetails,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      ['targetInventory', 'targetInventory.inventory', 'targetInventory.orderProduct']
+    )
+
+    let worksheetDetailIds: string[] = []
+    let targetInventoryIds: string[] = []
+
+    for (const worksheetDetail of worksheetDetails) {
+      worksheetDetailIds.push(worksheetDetail.id)
+      const targetInventory: OrderInventory = worksheetDetail.targetInventory
+      targetInventoryIds.push(targetInventory.id)
+
+      let inventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { id: worksheetDetail.targetInventory.inventory.id } })
+      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 as any }
+        )
+    }
+
+    await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetailIds)
+    await this.trxMgr.getRepository(OrderInventory).delete(targetInventoryIds)
+
+    await this.trxMgr.getRepository(OrderInventory).update(
+      {
+        refWorksheetId: worksheet.id,
+        batchId,
+        product: { id: productId },
+        packingType,
+        packingSize,
+        status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT
+      },
+      {
+        status: ORDER_INVENTORY_STATUS.PENDING_SPLIT,
+        updater: this.user as any,
+        updatedAt: new Date() as any
+      }
+    )
+  }
+
+  async scanProductPicking(
+    worksheetDetailName: string,
+    worksheetType: string,
+    productBarcode: string,
+    cartonId: string,
+    binLocation?: string,
+    serialNumber?: string,
+    toteNo?: string,
+    pickedQty: number = 1
+  ): Promise<WorksheetDetail> {
+    try {
+      //find existing worksheet detail
+      let worksheetDetail: WorksheetDetail = await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wd')
+        .innerJoinAndSelect('wd.worksheet', 'ws')
+        .innerJoinAndSelect('ws.bizplace', 'bz')
+        .innerJoinAndSelect('wd.targetInventory', 'oi')
+        .innerJoinAndSelect('oi.releaseGood', 'rg')
+        .innerJoinAndSelect('oi.inventory', 'inv')
+        .leftJoinAndSelect('oi.orderProduct', 'op')
+        .innerJoinAndSelect('oi.product', 'prd')
+        .leftJoinAndSelect(
+          'prd.productDetails',
+          'pd',
+          'pd.product_id = oi.product_id AND pd.deleted_at is null AND pd.packing_type = oi.packing_type AND pd.packing_size = oi.packing_size AND pd.uom = oi.uom'
+        )
+        .where('wd.name = :name', { name: worksheetDetailName })
+        .andWhere('wd.domain_id = :domainId', { domainId: this.domain.id })
+        .andWhere('wd.type = :type', { type: worksheetType })
+        .andWhere('wd.status = :status', { status: WORKSHEET_STATUS.EXECUTING })
+        .andWhere('inv.carton_id = :cartonId', { cartonId: cartonId })
+        .getOne()
+
+      //validation to check matching worksheet detail based on name
+      if (!worksheetDetail || !worksheetDetail.targetInventory)
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheetDetailName))
+
+      //validation to prevent duplicated picking
+      if (worksheetDetail?.targetInventory?.status != ORDER_INVENTORY_STATUS.PICKING)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
+
+      let matchingProduct = await this.getDirectQty(
+        {
+          ...worksheetDetail?.targetInventory?.product?.productDetails[0],
+          product: worksheetDetail?.targetInventory?.product
+        },
+        productBarcode,
+        pickedQty
+      )
+
+      //validate matching product details based on scanned barcode
+      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+
+      pickedQty = matchingProduct.qty
+      let pickedUomValue = matchingProduct.uomValue
+
+      //validation to prevent over release
+      if (
+        !worksheetDetail?.targetInventory ||
+        worksheetDetail?.targetInventory.inventory.qty < 1 ||
+        pickedQty + (worksheetDetail.targetInventory?.pickedQty || 0) > worksheetDetail.targetInventory.releaseQty
+      )
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+
+      let targetInventory: OrderInventory = worksheetDetail.targetInventory
+      let targetProduct: OrderProduct = targetInventory.orderProduct
+      let inventory: Inventory = targetInventory.inventory
+      let bizplace: Bizplace = worksheetDetail.worksheet.bizplace
+      const product: Product = targetInventory.product
+
+      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+
+      // for required outbound serial number scanning
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
+
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory: { id: inventory.id },
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
+          }
+        })
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: { id: this.domain.id }, serialNumber: serialNumber, product: { id: product.id } }
+        })
+
+        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)
+        }
+      }
+
+      // for tote scanning
+      if (toteNo) {
+        await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace)
+      }
+
+      // temporarily override with separate logic to handle transaction to speed up function
+      // await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+
+      const releaseQty: number = targetInventory.releaseQty
+
+      targetInventory.pickedQty = (targetInventory?.pickedQty || 0) + pickedQty
+
+      let updateOiObj = {
+        pickedQty: () => `"picked_qty" + ${pickedQty}`,
+        updatedAt: new Date(),
+        updater: this.user,
+        pickedBy: this.user.name,
+        pickedByUser: this.user,
+        pickedAt: new Date()
+      }
+
+      if (targetInventory.pickedQty == releaseQty) {
+        updateOiObj['status'] = ORDER_INVENTORY_STATUS.PICKED
+      }
+
+      if (targetInventory.binLocation) {
+        updateOiObj['binLocation'] = targetInventory.binLocation
+      }
+
+      await this.trxMgr
+        .getRepository(OrderInventory)
+        .createQueryBuilder()
+        .update(OrderInventory)
+        .set(updateOiObj as any)
+        .where({ id: targetInventory.id })
+        .andWhere(`picked_qty + :pickedQty <= release_qty`, { pickedQty })
+        .execute()
+
+      if (targetInventory.pickedQty == releaseQty) {
+        //update worksheet details only when line item picking complete
+        await this.trxMgr
+          .getRepository(WorksheetDetail)
+          .createQueryBuilder()
+          .update(WorksheetDetail)
+          .set({
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user,
+            updatedAt: new Date()
+          })
+          .where('id = :id', { id: worksheetDetail.id })
+          .execute()
+
+        getConnection().transaction(async (tx: EntityManager) => {
+          let releaseUomValue = Math.round((pickedUomValue / pickedQty) * releaseQty * 100) / 100
+
+          let updateInvObj = {
+            qty: () => `"qty" - ${releaseQty}`,
+            lockedQty: () => `"locked_qty" - ${releaseQty}`,
+            uomValue: () => `"uom_value" - ${releaseUomValue}`,
+            lockedUomValue: () => `"locked_uom_value" - ${releaseUomValue}`,
+            updater: this.user,
+            updatedAt: new Date()
+          }
+
+          let remainingQty = await tx
+            .getRepository(Inventory)
+            .createQueryBuilder()
+            .update(Inventory)
+            .set(updateInvObj as any)
+            .where('id = :id', { id: targetInventory.inventory.id })
+            .returning(['qty'])
+            .execute()
+            .then(dt => {
+              return dt.raw[0].qty
+            })
+
+          await generateInventoryHistory(
+            inventory,
+            releaseGood,
+            INVENTORY_TRANSACTION_TYPE.PICKING,
+            -releaseQty,
+            -releaseUomValue,
+            this.user,
+            tx
+          )
+
+          //@ts-ignore
+          let inventoryItems: InventoryItem = await tx
+            .getRepository(InventoryItem)
+            .find({ where: { outboundOrderId: releaseGood.id } })
+
+          //@ts-ignore
+          if (inventoryItems.length > 0) {
+            //@ts-ignore
+            inventoryItems.forEach((itm: InventoryItem) => {
+              itm.status = INVENTORY_STATUS.PICKED
+              itm.updater = this.user
+            })
+
+            await tx.getRepository(InventoryItem).save(inventoryItems)
+          }
+
+          if (remainingQty === 0) {
+            await tx
+              .getRepository(Inventory)
+              .createQueryBuilder()
+              .update(Inventory)
+              .set({ status: INVENTORY_STATUS.TERMINATED })
+              .where('id = :id', { id: targetInventory.inventory.id })
+              .execute()
+
+            await generateInventoryHistory(
+              inventory,
+              releaseGood,
+              INVENTORY_TRANSACTION_TYPE.TERMINATED,
+              0,
+              0,
+              this.user,
+              tx
+            )
+          }
+        })
+      }
+
+      // return worksheet details
+      worksheetDetail = await this.trxMgr
+        .getRepository(WorksheetDetail)
+        .createQueryBuilder('wd')
+        .innerJoin('wd.targetInventory', 'oi')
+        .innerJoinAndSelect('oi.releaseGood', 'rg')
+        .where('wd.id = :id', { id: worksheetDetail.id })
+        .getOne()
+
+      return worksheetDetail
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async picking(
+    worksheetDetailName: string,
+    worksheetType: string,
+    palletId: string,
+    locationName: string,
+    pickedQty: number,
+    binLocation?: string,
+    serialNumber?: string,
+    toteNo?: string
+  ): Promise<void> {
+    try {
+      let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
+        worksheetDetailName,
+        worksheetType,
+        [
+          'worksheet',
+          'worksheet.bizplace',
+          'targetInventory',
+          'targetInventory.releaseGood',
+          'targetInventory.orderProduct',
+          'targetInventory.inventory',
+          '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
+      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({
+        where: { domain: { id: this.domain.id }, id: targetInventory.id, status: ORDER_INVENTORY_STATUS.PICKING }
+      })
+      if (!oiValidate) throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
+
+      //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)
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
+
+      if (product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `require serial number`))
+        }
+
+        let totalInventoryItems = await this.trxMgr.getRepository(InventoryItem).count({
+          where: {
+            inventory: { id: inventory.id },
+            status: Not(In([INVENTORY_STATUS.TERMINATED, INVENTORY_STATUS.PICKED]))
+          }
+        })
+
+        let foundSerialNumber: InventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: { id: this.domain.id }, serialNumber: serialNumber, product: { id: product.id } },
+          relations: ['product', 'inventory']
+        })
+
+        let scannedPalletIdInventory: Inventory = await this.trxMgr
+          .getRepository(Inventory)
+          .findOne({ where: { domain: { id: this.domain.id }, 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: { id: this.domain.id },
+              inventory: { id: scannedPalletIdInventory.id },
+              releaseGood: { id: releaseGood.id }
+            }
+          })
+
+          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
+      if (locationName) {
+        const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+          where: { domain: { id: this.domain.id }, name: locationName },
+          relations: ['warehouse']
+        })
+
+        if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
+
+        if (fromLocation.id !== toLocation.id) {
+          inventory.location = toLocation
+          inventory.warehouse = toLocation.warehouse
+          inventory.zone = toLocation.zone
+          inventory = await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.RELOCATE)
+        }
+      }
+    } catch (error) {
+      throw error
+    }
+  }
+
+  async batchPicking(
+    taskNo: string,
+    worksheetType: string,
+    palletId: string,
+    locationName: string,
+    binLocationName: string,
+    releaseQty: number
+  ): Promise<void> {
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: { domain: { id: this.domain.id }, taskNo, type: worksheetType, status: WORKSHEET_STATUS.EXECUTING }
+    })
+
+    const foundInventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({
+      where: { domain: { id: this.domain.id }, palletId }
+    })
+
+    const targetInventories: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
+      where: {
+        domain: { id: this.domain.id },
+        refWorksheetId: worksheet.id,
+        status: ORDER_INVENTORY_STATUS.PICKING,
+        inventory: { id: foundInventory.id }
+      },
+      relations: ['inventory', 'inventory.location', 'releaseGood']
+    })
+
+    const targetInventoryId: string[] = targetInventories.map((oi: OrderInventory) => oi.id)
+
+    let worksheetDetails: WorksheetDetail[] = await this.trxMgr.getRepository(WorksheetDetail).find({
+      where: {
+        domain: { id: this.domain.id },
+        type: worksheetType,
+        status: WORKSHEET_STATUS.EXECUTING,
+        targetInventory: { id: In(targetInventoryId) }
+      }
+    })
+
+    const sumOfReleaseQty: number = targetInventories
+      .map((oi: OrderInventory) => oi.releaseQty)
+      .reduce((a, b) => a + b, 0)
+
+    if (sumOfReleaseQty != releaseQty)
+      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `insufficient picking quantity`))
+
+    for (var i = 0; i < targetInventories.length; i++) {
+      let targetInventory: OrderInventory = targetInventories[i]
+      let inventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne({
+        where: { domain: { id: this.domain.id }, id: targetInventory.inventory.id }
+      })
+
+      const releaseGood: ReleaseGood = targetInventory.releaseGood
+
+      if (inventory.palletId !== palletId)
+        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Pallet ID', palletId, inventory.palletId))
+
+      const leftQty: number = inventory.qty - targetInventory.releaseQty
+      if (leftQty < 0) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+      }
+
+      if (binLocationName) {
+        const binLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+          where: { domain: { id: this.domain.id }, name: binLocationName, type: LOCATION_TYPE.BIN }
+        })
+
+        if (!binLocation)
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+
+        targetInventory.binLocation = binLocation
+      }
+
+      targetInventory.pickedQty = targetInventory.releaseQty
+      targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
+      await this.updateOrderTargets([targetInventory])
+
+      inventory.qty -= targetInventory.releaseQty
+      inventory.uomValue = Math.round((inventory.uomValue - targetInventory.releaseUomValue) * 100) / 100
+      inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
+      inventory.lockedUomValue = Math.round((inventory.lockedUomValue - targetInventory.releaseUomValue) * 100) / 100
+      await this.transactionInventory(
+        inventory,
+        releaseGood,
+        -targetInventory.releaseQty,
+        -targetInventory.releaseUomValue,
+        INVENTORY_TRANSACTION_TYPE.PICKING
+      )
+
+      if (leftQty === 0) {
+        inventory.status = INVENTORY_STATUS.TERMINATED
+        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+      }
+
+      const fromLocation: Location = targetInventory.inventory.location
+      if (locationName) {
+        const toLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+          where: { domain: { id: this.domain.id }, name: locationName },
+          relations: ['warehouse']
+        })
+
+        if (!toLocation) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(locationName))
+
+        if (fromLocation.id !== toLocation.id) {
+          inventory.location = toLocation
+          inventory.warehouse = toLocation.warehouse
+          inventory.zone = toLocation.zone
+          await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.RELOCATE)
+        }
+      }
+    }
+
+    worksheetDetails = worksheetDetails.map((worksheetDetail: WorksheetDetail) => {
+      return {
+        ...worksheetDetail,
+        status: WORKSHEET_STATUS.DONE,
+        updater: this.user
+      }
+    })
+    await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetails)
+  }
+
+  async scanProductBatchPicking(
+    taskNo: string,
+    worksheetType: string,
+    cartonId: string,
+    productBarcode: string,
+    inventory: any,
+    binLocationName: string,
+    pickingQty: number
+  ): Promise<void> {
+    const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: { domain: { id: this.domain.id }, taskNo, type: worksheetType, status: WORKSHEET_STATUS.EXECUTING },
+      relations: [
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.releaseGood',
+        'worksheetDetails.targetInventory.inventory',
+        'worksheetDetails.targetInventory.inventory.location',
+        'worksheetDetails.targetInventory.product',
+        'worksheetDetails.targetInventory.product.productDetails',
+        'worksheetDetails.targetInventory.product.productDetails.childProductDetail'
+      ]
+    })
+
+    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+    const product: Product = worksheetDetails
+      .map((wsd: WorksheetDetail) => wsd.targetInventory.product)
+      .find((product: Product) => product.id === inventory.product.id)
+
+    const batchId: string = inventory.batchId
+    const packingType: string = inventory.packingType
+    const packingSize: number = inventory.packingSize
+    let pickedQty: number = pickingQty ? pickingQty : 1
+
+    const targetInventories: OrderInventory[] = worksheetDetails
+      .map((wsd: WorksheetDetail) => wsd.targetInventory)
+      .filter(
+        (targetInventory: OrderInventory) =>
+          targetInventory.batchId === batchId &&
+          targetInventory.packingType === packingType &&
+          targetInventory.inventory.cartonId === cartonId &&
+          targetInventory.product.id === product.id
+      )
+
+    // search for matching product barcode
+    const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
+    const isMatchingBarcode: boolean = productDetails.map(detail => detail.gtin).includes(productBarcode)
+    if (!isMatchingBarcode) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(`GTIN (${productBarcode})`))
+
+    // case for scanning parent packing type, packing size
+    const foundProductDetail: ProductDetail = productDetails.find(
+      (detail: ProductDetail) =>
+        detail.gtin === productBarcode && detail.packingType === packingType && detail.packingSize == packingSize
+    )
+
+    if (!foundProductDetail) {
+      const roProductDetail: ProductDetail = productDetails.find(
+        (parentDetail: ProductDetail) =>
+          parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
+      )
+      if (!roProductDetail)
+        throw new Error(
+          this.ERROR_MSG.FIND.NO_RESULT(`Packing Type ( ${packingType}) or Packing Size (${packingSize})`)
+        )
+
+      let childQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+      pickedQty *= childQty
+    }
+
+    const sumOfReleaseQty: number = targetInventories
+      .map((oi: OrderInventory) => oi.releaseQty)
+      .reduce((a, b) => a + b, 0)
+
+    const sumOfPickedQty: number =
+      targetInventories.map((oi: OrderInventory) => oi.pickedQty).reduce((a, b) => a + b, 0) + pickedQty
+
+    if (sumOfPickedQty > sumOfReleaseQty)
+      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+
+    for (var i = 0; i < targetInventories.length; i++) {
+      let targetInventory: OrderInventory = targetInventories[i]
+      let inventory: Inventory = targetInventory.inventory
+      const targetReleaseQty: number = targetInventory.releaseQty
+      const targetPickedQty: number = targetInventory.pickedQty
+      const releaseGood: ReleaseGood = targetInventory.releaseGood
+      if (pickedQty <= 0) break
+
+      if (
+        targetInventory.status === ORDER_INVENTORY_STATUS.PICKING &&
+        targetReleaseQty > targetPickedQty &&
+        pickedQty > 0
+      ) {
+        let remainingAssignedQty: number = pickedQty - (targetReleaseQty - targetPickedQty) // -1, 0, 1
+        const gapQtyRemaining: number = targetReleaseQty - targetPickedQty // > 0
+
+        if (binLocationName && !targetInventory?.binLocation) {
+          const binLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+            where: { domain: { id: this.domain.id }, name: binLocationName, type: LOCATION_TYPE.BIN }
+          })
+
+          if (!binLocation)
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+
+          targetInventory.binLocation = binLocation
+        }
+
+        //  pickedQty = 1, gap = 5 || pickedQty = 12, gap = 5 || pickedQty = 5, gap = 5
+        targetInventory.pickedQty += pickedQty > gapQtyRemaining ? gapQtyRemaining : pickedQty
+        remainingAssignedQty = remainingAssignedQty < 0 ? 0 : remainingAssignedQty
+
+        if (targetInventory.pickedQty == targetReleaseQty) {
+          const leftQty: number = inventory.qty - targetInventory.releaseQty
+          if (leftQty < 0) {
+            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+          }
+
+          targetInventory.status = ORDER_INVENTORY_STATUS.PICKED
+          await this.updateOrderTargets([targetInventory])
+
+          inventory.qty -= targetInventory.releaseQty
+          inventory.uomValue = Math.round((inventory.uomValue - targetInventory.releaseUomValue) * 100) / 100
+          inventory.lockedQty = inventory.lockedQty - targetInventory.releaseQty
+          inventory.lockedUomValue =
+            Math.round((inventory.lockedUomValue - targetInventory.releaseUomValue) * 100) / 100
+          await this.transactionInventory(
+            inventory,
+            releaseGood,
+            -targetInventory.releaseQty,
+            -targetInventory.releaseUomValue,
+            INVENTORY_TRANSACTION_TYPE.PICKING
+          )
+
+          if (leftQty === 0) {
+            inventory.status = INVENTORY_STATUS.TERMINATED
+            await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.TERMINATED)
+          }
+
+          let worksheetDetail: WorksheetDetail = worksheetDetails.find(
+            (wsd: WorksheetDetail) => wsd.targetInventory.id === targetInventory.id
+          )
+          worksheetDetail.status = WORKSHEET_STATUS.DONE
+          worksheetDetail.updater = this.user
+          await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+        } else {
+          await this.updateOrderTargets([targetInventory])
+        }
+        pickedQty = pickedQty - (targetReleaseQty - targetPickedQty)
+      }
+    }
+  }
+
+  async completePicking(releaseGoodNo: string): Promise<Worksheet> {
+    //@ts-ignore
+    let releaseGood: ReleaseGood = await this.findRefOrder(ReleaseGood, {
+      domain: { id: this.domain.id },
+      name: releaseGoodNo,
+      status: ORDER_STATUS.PICKING
+    })
+
+    const foundNotSealedOrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { releaseGood: { id: releaseGood.id }, 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 })
+
+    //@ts-ignore
+    let inventoryItems: InventoryItem = await this.trxMgr
+      .getRepository(InventoryItem)
+      .find({ where: { outboundOrderId: releaseGood.id } })
+
+    //@ts-ignore
+    if (inventoryItems.length > 0) {
+      //@ts-ignore
+      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?.packingOption) {
+      orderStatus = ORDER_STATUS.READY_TO_PACK
+    } else {
+      orderStatus = ORDER_STATUS.LOADING
+    }
+
+    return await this.completeWorksheet(worksheet, orderStatus)
+  }
+
+  async completeBatchPicking(taskNo: string): Promise<Worksheet> {
+    let worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: this.domain.id },
+        taskNo,
+        type: WORKSHEET_TYPE.BATCH_PICKING
+      },
+      relations: [
+        'bizplace',
+        'bizplace.domain',
+        'worksheetDetails',
+        'worksheetDetails.targetInventory',
+        'worksheetDetails.targetInventory.releaseGood'
+      ]
+    })
+
+    this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
+
+    worksheet.status = WORKSHEET_STATUS.DONE
+    worksheet.endedAt = new Date()
+    worksheet.updater = this.user
+    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+
+    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[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+      let targetInventory: OrderInventory = wsd.targetInventory
+      targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+      targetInventory.updater = this.user
+      return targetInventory
+    })
+    await this.updateOrderTargets(targetInventories)
+
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map((wsd: WorksheetDetail) => {
+      let releaseGood: ReleaseGood = wsd.targetInventory.releaseGood
+
+      let orderStatus: string
+      if (releaseGood?.packingOption) {
+        orderStatus = ORDER_STATUS.READY_TO_PACK
+      } else {
+        orderStatus = ORDER_STATUS.READY_TO_SORT
+      }
+
+      releaseGood.status = orderStatus
+      releaseGood.updater = this.user
+      return releaseGood
+    })
+    await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
+
+    return worksheet
+  }
+
+  private async extractMatchedWorksheetDetails(
+    worksheetDetails: Partial<WorksheetDetail[]>,
+    standardBatchId: string,
+    standardProductId: string,
+    standardPackingType: string,
+    standardPackingSize: number,
+    relations: string[] = ['targetInventory', 'targetInventory.product']
+  ): Promise<WorksheetDetail[]> {
+    for (let wsd of worksheetDetails) {
+      if (!wsd.targetInventory?.batchId || !wsd.targetInventory?.product?.id || !wsd.targetInventory?.packingType) {
+        wsd = await this.findWorksheetDetail(wsd, ['targetInventory', 'targetInventory.product'])
+      }
+    }
+
+    worksheetDetails = worksheetDetails.filter(
+      (wsd: WorksheetDetail) =>
+        wsd.targetInventory.batchId === standardBatchId &&
+        wsd.targetInventory.product.id === standardProductId &&
+        wsd.targetInventory.packingType === standardPackingType &&
+        wsd.targetInventory.packingSize === standardPackingSize
+    )
+
+    for (let wsd of worksheetDetails) {
+      wsd = await this.findWorksheetDetail(wsd, relations)
+    }
+
+    return worksheetDetails
+  }
+
+  private async checkAndSetBinPicking(orderInventory, binLocation) {
+    // bin picking validation
+    if (binLocation) {
+      const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+        where: { domain: { id: this.domain.id }, name: binLocation, type: LOCATION_TYPE.BIN }
+      })
+
+      if (!foundBinLocation)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+
+      orderInventory.binLocation = foundBinLocation
+    }
+
+    return orderInventory
+  }
+
+  private async updatePickingTransaction(releaseGood, orderInventory, worksheetDetail, inventory, pickedQty) {
+    const releaseQty: number = orderInventory.releaseQty
+
+    orderInventory.pickedQty = (orderInventory?.pickedQty || 0) + pickedQty
+    if (orderInventory.pickedQty == releaseQty) {
+      const leftQty: number = inventory.qty - releaseQty
+      if (leftQty < 0) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `quantity can't exceed limitation`))
+      }
+
+      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
+      inventory.lockedQty = inventory.lockedQty - orderInventory.releaseQty
+      inventory.lockedUomValue = Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100
+      inventory = await this.transactionInventory(
+        inventory,
+        releaseGood,
+        -orderInventory.releaseQty,
+        -orderInventory.releaseUomValue,
+        INVENTORY_TRANSACTION_TYPE.PICKING
+      )
+
+      worksheetDetail.status = WORKSHEET_STATUS.DONE
+      worksheetDetail.updater = this.user
+      await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+
+      //@ts-ignore
+      let inventoryItems: InventoryItem = await this.trxMgr
+        .getRepository(InventoryItem)
+        .find({ where: { outboundOrderId: releaseGood.id } })
+
+      //@ts-ignore
+      if (inventoryItems.length > 0) {
+        //@ts-ignore
+        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)
+      }
+    }
+
+    await this.updateOrderTargets([orderInventory])
+
+    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: { id: this.domain.id }, id: existingOrderInv?.inventoryId } })
+
+      let newOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: { id: this.domain.id }, id: existingOrderInv?.id } })
+
+      let oldInventory: Inventory = await this.trxMgr
+        .getRepository(Inventory)
+        .findOne({ where: { domain: { id: this.domain.id }, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: { id: this.domain.id }, 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: { id: this.domain.id }, id: targetInventory?.inventory.id } })
+
+      let oldOrderInventory: OrderInventory = await this.trxMgr
+        .getRepository(OrderInventory)
+        .findOne({ where: { domain: { id: this.domain.id }, 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: { id: bizplace.id }, 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: { id: this.domain.id }, name: toteNo, releaseGood: { id: releaseGood.id } } })
+
+    //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).findOneBy({
+        domain: { id: this.domain.id },
+        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: { id: this.domain.id },
+        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)
+    }
+
+    //@ts-ignore
+    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 } })
+
+    //@ts-ignore
+    if (InventoryItems.length > 0) {
+      //@ts-ignore
+      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 as any
+        }
+      )
+    }
+
+    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: { id: this.domain.id }, name: orderNo }, relations: ['bizplace', 'bizplace.domain'] })
+
+    let sealNoSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
+      where: {
+        domain: { id: releaseGood.bizplace.domain.id },
+        name: 'minimum-seal-number'
+      }
+    })
+
+    if (!sealNoSetting) {
+      sealNoSetting = await this.trxMgr.getRepository(Setting).findOne({
+        where: {
+          domain: { id: this.domain.id },
+          name: 'minimum-seal-number'
+        }
+      })
+    }
+
+    const foundOrderTote: OrderTote = await this.trxMgr
+      .getRepository(OrderTote)
+      .findOne({ where: { domain: { id: this.domain.id }, name: toteNo, releaseGood: { id: releaseGood.id } } })
+
+    if (!foundOrderTote) {
+      throw new Error('Tote not scanned under this order')
+    }
+
+    let totalOrderToteItems = await this.trxMgr.getRepository(OrderToteItem).count({
+      where: {
+        orderTote: { id: foundOrderTote.id }
+      }
+    })
+
+    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).countBy({
+      orderTote: foundOrderTote
+    })
+
+    //@ts-ignore
+    if (totalSeal >= parseInt(sealNoSetting?.value || 0)) {
+      await this.trxMgr.getRepository(OrderTote).save({
+        ...foundOrderTote,
+        closedDate: new Date()
+      })
+    }
+  }
+}