@things-factory/worksheet-base 4.3.138 → 4.3.140

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

@@ -31,6 +31,7 @@ import {
   TOTE_STATUS,
   generateInventoryHistory
 } from '@things-factory/warehouse-base'
+import { logger } from '@things-factory/env'
 
 import { TASK_NUMBER_RULE_TYPE, TASK_NUMBER_SETTING_KEY, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
 import { Worksheet, WorksheetDetail } from '../../entities'
@@ -991,148 +992,144 @@ export class PickingWorksheetController extends VasWorksheetController {
     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 },
-      relations: [
-        'worksheetDetails',
-        'worksheetDetails.targetInventory',
-        'worksheetDetails.targetInventory.releaseGood',
-        'worksheetDetails.targetInventory.inventory',
-        'worksheetDetails.targetInventory.inventory.location',
-        'worksheetDetails.targetInventory.productDetail',
-        'worksheetDetails.targetInventory.productDetail.product',
-        'worksheetDetails.targetInventory.product',
-        'worksheetDetails.targetInventory.product.productDetails',
-        'worksheetDetails.targetInventory.product.productDetails.childProductDetail'
-      ]
-    })
+    try {
+      console.time(`scanProductBatchPicking:${taskNo}`)
+      const worksheet: Worksheet = await this.trxMgr
+        .getRepository(Worksheet)
+        .createQueryBuilder('worksheet')
+        .innerJoinAndSelect('worksheet.worksheetDetails', 'worksheetDetails')
+        .innerJoinAndSelect('worksheetDetails.targetInventory', 'targetInventory')
+        .innerJoinAndSelect('targetInventory.product', 'product')
+        .leftJoinAndSelect('targetInventory.productDetail', 'productDetail')
+        .leftJoinAndSelect('targetInventory.inventory', 'inventory')
+        .leftJoinAndSelect('inventory.location', 'location')
+        .leftJoinAndSelect('targetInventory.releaseGood', 'releaseGood')
+        .where('worksheet.domain_id = :domainId', { domainId: this.domain.id })
+        .andWhere('worksheet.task_no = :taskNo', { taskNo })
+        .andWhere('worksheet.type = :type', { type: worksheetType })
+        .andWhere('worksheet.status = :status', { status: WORKSHEET_STATUS.EXECUTING })
+        .getOne()
+      const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+      const productDetail: ProductDetail = worksheetDetails
+        .map(wsd => wsd.targetInventory.productDetail)
+        .find(productDetail => productDetail.id === inventory.productDetail.id)
 
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    const productDetail: ProductDetail = worksheetDetails
-      .map(wsd => wsd.targetInventory.productDetail)
-      .find(productDetail => productDetail.id === inventory.productDetail.id)
+      const product: Product = productDetail.product
 
-    const product: Product = productDetail.product
+      const batchId: string = inventory.batchId
+      let pickedQty: number = pickingQty ? pickingQty : 1
+      let matchingProduct
 
-    const batchId: string = inventory.batchId
-    let pickedQty: number = pickingQty ? pickingQty : 1
-    let matchingProduct
+      const targetInventories: OrderInventory[] = worksheetDetails
+        .map((wsd: WorksheetDetail) => wsd.targetInventory)
+        .filter(
+          (targetInventory: OrderInventory) =>
+            targetInventory.batchId === batchId &&
+            targetInventory.inventory.cartonId === cartonId &&
+            targetInventory.productDetail.id === productDetail.id
+        )
 
-    const targetInventories: OrderInventory[] = worksheetDetails
-      .map((wsd: WorksheetDetail) => wsd.targetInventory)
-      .filter(
-        (targetInventory: OrderInventory) =>
-          targetInventory.batchId === batchId &&
-          targetInventory.inventory.cartonId === cartonId &&
-          targetInventory.productDetail.id === productDetail.id
+      matchingProduct = await this.getDirectQty(
+        {
+          ...productDetail,
+          product
+        },
+        productBarcode,
+        pickedQty
       )
 
-    matchingProduct = await this.getDirectQty(
-      {
-        ...productDetail,
-        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
-
-    // // search for matching product barcode
-    // const productDetails: ProductDetail[] = product?.productDetails.filter(detail => !detail.deletedAt)
-    // // scannedProductDetail can be child or gtin
-    // const scannedProductDetail: ProductDetail = productDetails.find(detail => detail.gtin == productBarcode)
-    // if (!scannedProductDetail) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      //validate matching product details based on scanned barcode
+      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
 
-    // // case for scanning parent packing type, packing size
-    // // when scannedProductDetail id is not the same as productDetail id, then it's not child gtin, proceed to get child qty
-    // if (scannedProductDetail.id !== productDetail.id) {
-    //   let childQty = await this.getChildQty(productDetails, productBarcode, productDetail, scannedProductDetail)
-    //   pickedQty *= childQty
-    // }
+      pickedQty = matchingProduct.qty
 
-    const sumOfReleaseQty: number = targetInventories
-      .map((oi: OrderInventory) => oi.releaseQty)
-      .reduce((a, b) => a + b, 0)
+      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
+      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`))
+      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
+      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: this.domain, name: binLocationName, type: LOCATION_TYPE.BIN }
+            })
 
-      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: this.domain, name: binLocationName, type: LOCATION_TYPE.BIN }
-          })
+            if (!binLocation)
+              throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
 
-          if (!binLocation)
-            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `invalid bin location id`))
+            targetInventory.binLocation = binLocation
+          }
 
-          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
 
-        //  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`)
+              )
+            }
 
-        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])
 
-          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
+            )
 
-          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)
+            }
 
-          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])
           }
-
-          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)
         }
-        pickedQty = pickedQty - (targetReleaseQty - targetPickedQty)
       }
+    } catch (error) {
+      logger.error(`picking-worksheet-controller[scanProductBatchPicking]: ${error}`)
+      throw new Error(error)
+    } finally {
+      console.timeEnd(`scanProductBatchPicking:${taskNo}`)
     }
   }
 
@@ -1437,7 +1434,9 @@ export class PickingWorksheetController extends VasWorksheetController {
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.ild)
         await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
-    } catch (e) {}
+    } catch (e) {
+      logger.error(`picking-worksheet-controller[serialNumberReplacementForExistingOrderInv]: ${e}`)
+    }
   }
 
   private async serialNumberReplacement(
@@ -1554,7 +1553,9 @@ export class PickingWorksheetController extends VasWorksheetController {
         await this.trxMgr.getRepository(WorksheetDetail).delete(worksheetDetail.id)
         await this.trxMgr.getRepository(OrderInventory).delete(targetInventory.id)
       }
-    } catch (e) {}
+    } catch (e) {
+      logger.error(`picking-worksheet-controller[serialNumberReplacement]: ${e}`)
+    }
   }
 
   private async toteScanning(toteNo, targetProduct, targetInventory, pickedQty, releaseGood, bizplace) {