@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

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

@@ -1,9 +1,10 @@
-import { Equal, In, IsNull, Not } from 'typeorm'
+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 {
+  GenerateBatchPickInfo,
   ORDER_INVENTORY_STATUS,
   ORDER_PRODUCT_STATUS,
   ORDER_STATUS,
@@ -32,11 +33,11 @@ import {
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
-import { WorksheetNoGenerator } from '../../utils'
+import { generateInventoryHistory, WorksheetNoGenerator } from '../../utils'
 import { VasWorksheetController } from '../vas/vas-worksheet-controller'
 
 export class PickingWorksheetController extends VasWorksheetController {
-  async generatePickingWorksheet(releaseGoodNo: string): Promise<Worksheet> {
+  async generatePickingWorksheet(releaseGoodNo: string, currentStatus: string = null): Promise<Worksheet> {
     let releaseGood: ReleaseGood = await this.findRefOrder(
       ReleaseGood,
       {
@@ -74,79 +75,91 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     releaseGood.status = ORDER_STATUS.READY_TO_PICK
     releaseGood.updater = this.user
-    await this.updateRefOrder(releaseGood)
+    await this.updateRefOrder(releaseGood, null, currentStatus)
 
     return worksheet
   }
 
-  async generateBatchPickingWorksheet(releaseGoodNos: [string], partnerBizplaceId: string): Promise<Worksheet> {
-    let releaseGoods: ReleaseGood[] = await this.trxMgr.getRepository(ReleaseGood).find({
-      where: { domain: this.domain, name: In(releaseGoodNos), status: ORDER_STATUS.PENDING_WORKSHEET },
-      relations: ['orderInventories', 'orderInventories.inventory']
-    })
+  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: this.domain, name: In(releaseGoodNos), status: ORDER_STATUS.PENDING_WORKSHEET },
+        relations: [
+          'orderProducts',
+          'orderProducts.product',
+          'orderInventories',
+          'orderInventories.inventory',
+          'bizplace',
+          'bizplace.domain'
+        ]
+      })
 
-    const partnerBizplace: Bizplace = await this.trxMgr.getRepository(Bizplace).findOne(partnerBizplaceId)
+      let orderInventories: OrderInventory[] = []
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        const foundOIs: OrderInventory[] = releaseGood.orderInventories
+        foundOIs.map((oi: OrderInventory) => {
+          orderInventories.push(oi)
+        })
+      })
 
-    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: this.domain,
+          name: TASK_NUMBER_SETTING_KEY.TASK_NO_RULE
+        }
       })
-    })
+      if (!worksheetSetting) throw new Error(this.ERROR_MSG.FIND.NO_RESULT('task number rule'))
 
-    const worksheetSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
-      where: {
+      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,
-        name: TASK_NUMBER_SETTING_KEY.TASK_NO_RULE
+        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
+        )
       }
-    })
-    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 = partnerBizplace
-    worksheet.domain = this.domain
-    worksheet.creator = this.user
-    worksheet.updater = this.user
-    worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
+      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)
 
-    if (orderInventories.some((oi: OrderInventory) => oi.inventory?.id)) {
-      const hasInventoryOIs: OrderInventory[] = orderInventories.filter(
-        (orderInventory: OrderInventory) => orderInventory.inventory !== null
-      )
+      releaseGoods = releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          status: ORDER_STATUS.READY_TO_PICK,
+          updater: this.user
+        }
+      })
+      await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
 
-      worksheet.worksheetDetails = await this.createWorksheetDetails(
-        worksheet,
-        WORKSHEET_TYPE.BATCH_PICKING,
-        hasInventoryOIs
-      )
+      worksheets.push(worksheet)
     }
-
-    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)
-
-    return worksheet
+    return worksheets
   }
 
   async generateBatchPickingWorksheetDetail(
@@ -219,6 +232,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       'worksheetDetails.targetInventory',
       'worksheetDetails.targetInventory.releaseGood',
       'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.releaseGood.orderProducts',
+      'worksheetDetails.targetInventory.releaseGood.orderProducts.product',
       'bizplace',
       'bizplace.domain',
       'bizplace.company',
@@ -236,12 +251,13 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     worksheet = await this.activateWorksheet(worksheet, worksheetDetails, [])
 
-    const completeSplitOIs: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
-      where: { domain: this.domain, refWorksheetId: worksheet.id, status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT },
+    // retrieve order inventory
+    const pickingOrderInventory: OrderInventory[] = await this.trxMgr.getRepository(OrderInventory).find({
+      where: { domain: this.domain, refWorksheetId: worksheet.id, status: ORDER_STATUS.PICKING },
       relations: ['releaseGood']
     })
 
-    let releaseGoods: ReleaseGood[] = completeSplitOIs.map((oi: OrderInventory) => oi.releaseGood)
+    let releaseGoods: ReleaseGood[] = pickingOrderInventory.map((oi: OrderInventory) => oi.releaseGood)
 
     if (releaseGoods?.length) {
       releaseGoods = releaseGoods.map((rg: ReleaseGood) => {
@@ -254,11 +270,6 @@ export class PickingWorksheetController extends VasWorksheetController {
       await this.trxMgr.getRepository(ReleaseGood).save(releaseGoods)
     }
 
-    if (completeSplitOIs?.length) {
-      const ids: string[] = completeSplitOIs.map((oi: OrderInventory) => oi.id)
-      await this.trxMgr.getRepository(OrderInventory).delete(ids)
-    }
-
     return worksheet
   }
 
@@ -305,8 +316,10 @@ export class PickingWorksheetController extends VasWorksheetController {
       }
 
       const targetInventory: OrderInventory = worksheetDetail.targetInventory
-      let inventory: Inventory = await this.trxMgr.getRepository(Inventory).findOne(targetInventory.inventory.id)
-      const product: Product = await this.trxMgr.getRepository(Product).findOne(productId)
+      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)
@@ -377,7 +390,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         .getRepository(OrderProduct)
         .update(
           { id: targetInventory.orderProduct.id },
-          { status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN, updater: this.user }
+          { status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN, updater: this.user as any }
         )
     }
 
@@ -393,7 +406,11 @@ export class PickingWorksheetController extends VasWorksheetController {
         packingSize,
         status: ORDER_INVENTORY_STATUS.COMPLETE_SPLIT
       },
-      { status: ORDER_INVENTORY_STATUS.PENDING_SPLIT, updater: this.user, updatedAt: new Date() }
+      {
+        status: ORDER_INVENTORY_STATUS.PENDING_SPLIT,
+        updater: this.user as any,
+        updatedAt: new Date() as any
+      }
     )
   }
 
@@ -404,81 +421,75 @@ export class PickingWorksheetController extends VasWorksheetController {
     cartonId: string,
     binLocation?: string,
     serialNumber?: string,
-    toteNo?: string
-  ): Promise<OrderInventory> {
+    toteNo?: string,
+    pickedQty: number = 1
+  ): Promise<WorksheetDetail> {
     try {
-      let worksheetDetail: WorksheetDetail = await this.findExecutableWorksheetDetailByName(
-        worksheetDetailName,
-        worksheetType,
-        [
-          'worksheet',
-          'worksheet.bizplace',
-          'targetInventory',
-          'targetInventory.releaseGood',
-          'targetInventory.inventory',
-          'targetInventory.product',
-          'targetInventory.orderProduct',
-          'targetInventory.product.productDetails',
-          'targetInventory.product.productDetails.product',
-          'targetInventory.product.productDetails.childProductDetail'
-        ]
-      )
+      //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()
 
-      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 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
-      let oiValidate: OrderInventory = await this.trxMgr.getRepository(OrderInventory).findOne({
-        where: { domain: this.domain, 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.cartonId !== cartonId)
-        throw new Error(this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('Carton ID', cartonId, inventory.cartonId))
+      if (worksheetDetail?.targetInventory?.status != ORDER_INVENTORY_STATUS.PICKING)
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `is done`))
 
-      const packingType: string = inventory.packingType
-      const packingSize: number = inventory.packingSize
+      let matchingProduct = await this.getDirectQty(
+        {
+          ...worksheetDetail?.targetInventory?.product?.productDetails[0],
+          product: worksheetDetail?.targetInventory?.product
+        },
+        productBarcode,
+        pickedQty
+      )
 
-      let pickedQty: number = 1
-      const releaseQty: number = targetInventory.releaseQty
+      //validate matching product details based on scanned barcode
+      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-      targetInventory = await this.checkAndSetBinPicking(targetInventory, binLocation)
+      pickedQty = matchingProduct.qty
+      let pickedUomValue = matchingProduct.uomValue
 
-      // 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(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 &&
-          detail.product?.id === product.id
+      //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`))
 
-      if (!foundProductDetail && !product?.isRequireSerialNumberScanningOutbound) {
-        const roProductDetail: ProductDetail = productDetails.find(
-          (parentDetail: ProductDetail) =>
-            parentDetail.packingType === packingType && parentDetail.packingSize == packingSize
-        )
+      const releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
 
-        pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
-        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))
-      }
+      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`))
@@ -531,11 +542,137 @@ export class PickingWorksheetController extends VasWorksheetController {
         }
       }
 
+      // for tote scanning
       if (toteNo) {
         await this.toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace)
       }
 
-      await this.updatePickingTransaction(releaseGood, targetInventory, worksheetDetail, inventory, pickedQty)
+      // 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
+          )
+
+          let inventoryItems: InventoryItem = await tx
+            .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 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
     }
@@ -830,7 +967,8 @@ export class PickingWorksheetController extends VasWorksheetController {
     cartonId: string,
     productBarcode: string,
     inventory: any,
-    binLocationName: string
+    binLocationName: string,
+    pickingQty: number
   ): Promise<void> {
     const worksheet: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne({
       where: { domain: this.domain, taskNo, type: worksheetType, status: WORKSHEET_STATUS.EXECUTING },
@@ -854,7 +992,7 @@ export class PickingWorksheetController extends VasWorksheetController {
     const batchId: string = inventory.batchId
     const packingType: string = inventory.packingType
     const packingSize: number = inventory.packingSize
-    let pickedQty: number = 1
+    let pickedQty: number = pickingQty ? pickingQty : 1
 
     const targetInventories: OrderInventory[] = worksheetDetails
       .map((wsd: WorksheetDetail) => wsd.targetInventory)
@@ -887,7 +1025,8 @@ export class PickingWorksheetController extends VasWorksheetController {
           this.ERROR_MSG.FIND.NO_RESULT(`Packing Type ( ${packingType}) or Packing Size (${packingSize})`)
         )
 
-      pickedQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+      let childQty = await this.getChildQty(productDetails, productBarcode, roProductDetail)
+      pickedQty *= childQty
     }
 
     const sumOfReleaseQty: number = targetInventories
@@ -1003,15 +1142,6 @@ export class PickingWorksheetController extends VasWorksheetController {
         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)
     }
 
@@ -1113,25 +1243,15 @@ export class PickingWorksheetController extends VasWorksheetController {
 
   private async checkAndSetBinPicking(orderInventory, binLocation) {
     // bin picking validation
-    const binPickingSetting: Setting = await this.trxMgr.getRepository(Setting).findOne({
-      where: {
-        domain: this.domain,
-        name: 'enable-bin-picking'
-      }
-    })
-    if (binPickingSetting != undefined && binPickingSetting.value.toLowerCase() == 'true') {
-      if (binLocation) {
-        const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
-          where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
-        })
-
-        if (!foundBinLocation)
-          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+    if (binLocation) {
+      const foundBinLocation: Location = await this.trxMgr.getRepository(Location).findOne({
+        where: { domain: this.domain, name: binLocation, type: LOCATION_TYPE.BIN }
+      })
 
-        orderInventory.binLocation = foundBinLocation
-      } else {
+      if (!foundBinLocation)
         throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
-      }
+
+      orderInventory.binLocation = foundBinLocation
     }
 
     return orderInventory
@@ -1140,7 +1260,7 @@ export class PickingWorksheetController extends VasWorksheetController {
   private async updatePickingTransaction(releaseGood, orderInventory, worksheetDetail, inventory, pickedQty) {
     const releaseQty: number = orderInventory.releaseQty
 
-    orderInventory.pickedQty = Boolean(orderInventory?.pickedQty) ? orderInventory.pickedQty + pickedQty : pickedQty
+    orderInventory.pickedQty = (orderInventory?.pickedQty || 0) + pickedQty
     if (orderInventory.pickedQty == releaseQty) {
       const leftQty: number = inventory.qty - releaseQty
       if (leftQty < 0) {
@@ -1451,8 +1571,8 @@ export class PickingWorksheetController extends VasWorksheetController {
       }
 
       //if found order tote then check if order tote item exist
-      const foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOne({
-        domain: this.domain,
+      const foundOrderToteItem: OrderToteItem = await this.trxMgr.getRepository(OrderToteItem).findOneBy({
+        domain: { id: this.domain.id },
         orderProduct: targetProduct,
         orderInventory: targetInventory,
         orderTote: foundOrderTote
@@ -1541,7 +1661,7 @@ export class PickingWorksheetController extends VasWorksheetController {
         {
           status: INVENTORY_STATUS.STORED,
           outboundOrderId: null,
-          updater: this.user
+          updater: this.user as any
         }
       )
     }
@@ -1607,7 +1727,7 @@ export class PickingWorksheetController extends VasWorksheetController {
       updater: this.user
     })
 
-    const totalSeal = await this.trxMgr.getRepository(OrderToteSeal).count({
+    const totalSeal = await this.trxMgr.getRepository(OrderToteSeal).countBy({
       orderTote: foundOrderTote
     })