@things-factory/worksheet-base 4.3.285 → 4.3.287

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

@@ -306,176 +306,154 @@ export class PackingWorksheetController extends VasWorksheetController {
   }
 
   async scanProductPacking(orderPackageItemId: string, productBarcode: string, serialNumber?: string): Promise<any> {
-    let orderPackageItem: OrderPackageItem = await this.trxMgr.getRepository(OrderPackageItem).findOne({
-      where: { id: orderPackageItemId },
-      relations: ['orderPackage', 'orderProduct', 'orderProduct.orderInventories']
-    })
-
-    const orderProduct: OrderProduct = orderPackageItem.orderProduct
-    const orderInventories: OrderInventory[] = orderProduct.orderInventories.filter(oi => oi.packedQty != oi.pickedQty)
-    let packedQty: number = 1
+    try {
+      let packedQty: number = 1
+      let orderPackageItem: OrderPackageItem = await this.trxMgr.getRepository(OrderPackageItem).findOne({
+        where: { id: orderPackageItemId }, relations: ['orderProduct', 'orderProduct.releaseGood']
+      })
+      const orderProduct: OrderProduct = orderPackageItem.orderProduct
+      const releaseGood: ReleaseGood = orderProduct.releaseGood
 
-    for (let orderInventory of orderInventories) {
-      let worksheetDetail: WorksheetDetail = await this.trxMgr
-        .getRepository(WorksheetDetail)
-        .createQueryBuilder('wd')
-        .innerJoinAndSelect('wd.bizplace', 'b')
-        .innerJoinAndSelect('wd.targetInventory', 'oi')
-        .innerJoinAndSelect('oi.releaseGood', 'rg')
-        .innerJoinAndSelect('oi.inventory', 'inv')
-        .leftJoinAndSelect('oi.orderProduct', 'op')
+      let orderInventory: OrderInventory = await this.trxMgr.getRepository(OrderInventory).createQueryBuilder('oi')
         .innerJoinAndSelect('oi.product', 'prd')
         .innerJoinAndSelect('oi.productDetail', 'pd')
-        .innerJoinAndSelect('pd.productBarcodes', 'pb')
-        .where('oi.id = :id', { id: orderInventory.id })
+        .innerJoinAndSelect('oi.inventory', 'inv')
+        .where('oi.order_product_id = :id', { id: orderProduct.id })
+        .andWhere('oi.packed_qty <> oi.picked_qty')
+        .orderBy('oi.created_at')
+        .addOrderBy('oi.name')
         .getOne()
 
-      let targetInventory: OrderInventory = worksheetDetail.targetInventory
-
-      let inventory: Inventory = targetInventory.inventory
-      let pickedQty: number = targetInventory.releaseQty
-      const releaseGood: ReleaseGood = targetInventory.releaseGood
-      const product: Product = targetInventory.product
-      const productDetail: ProductDetail = targetInventory.productDetail
-      const productBarcodes: [ProductBarcode] = productDetail.productBarcodes
-      let matchingProduct
 
-      if (!productBarcodes.find(itm => itm.gtin == productBarcode) && product?.isRequireSerialNumberScanningOutbound) {
-        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
+      // Validation: PackQty cannot be more than ReleaseQty
+      if (orderPackageItem !== null && orderInventory == null) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `unable to find suitable item`))
       }
 
-      matchingProduct = await this.getDirectQty(
+      const product: Product = orderInventory.product
+      const productDetail: ProductDetail = orderInventory.productDetail
+      const inventory: Inventory = orderInventory.inventory
+      const releaseQty: number = orderInventory.releaseQty
+
+      const matchingProduct = await this.getDirectQty(
         {
           ...productDetail,
-          product: targetInventory?.product
+          product: product
         },
         productBarcode,
         packedQty
       )
-
-      //validate matching product details based on scanned barcode
-      if (!matchingProduct) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(productBarcode))
-
       packedQty = matchingProduct.qty
 
-      if (packedQty + targetInventory.packedQty > pickedQty) {
-        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('picking', `over release`))
+      // Validation: PackQty cannot be more than ReleaseQty
+      if ((packedQty + orderInventory.packedQty) > orderInventory.releaseQty) {
+        throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `packed quantity can't exceed release qty`))
       }
 
-      // Serial Number scanning for batch picking
-      if (targetInventory?.refWorksheetId) {
-        if (product?.isRequireSerialNumberScanningOutbound) {
-          if (!serialNumber || serialNumber == '') {
-            throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
-          }
-
-          let foundSerialNumber: InventoryItem = await this.trxMgr
-            .getRepository(InventoryItem)
-            .findOne({ where: { domain: this.domain, serialNumber: serialNumber, productDetail } })
-
-          if (foundSerialNumber) {
-            if (foundSerialNumber.inventoryId !== inventory.id) {
-              throw new Error('Serial Number scanned is in another inventory')
-            }
+      // Validation: Serial Number scanning for batch picking
+      let inventoryItem: Partial<InventoryItem>
+      if (orderInventory?.refWorksheetId && product?.isRequireSerialNumberScanningOutbound) {
+        if (!serialNumber || serialNumber == '') {
+          throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('packing', `require serial number`))
+        }
 
-            if (foundSerialNumber.outboundOrderId) {
-              let releaseGood: ReleaseGood = await this.trxMgr
-                .getRepository(ReleaseGood)
-                .findOne({ where: { id: foundSerialNumber.outboundOrderId } })
-              throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
-            }
+        inventoryItem = await this.trxMgr.getRepository(InventoryItem).findOne({
+          where: { domain: this.domain, serialNumber: serialNumber, productDetail }
+        })
 
-            foundSerialNumber.status = INVENTORY_STATUS.PACKING
-            foundSerialNumber.updater = this.user
-            foundSerialNumber.outboundOrderId = releaseGood.id
+        if (inventoryItem) {
+          if (inventoryItem.inventoryId !== inventory.id) {
+            throw new Error('Serial Number scanned is in another inventory')
+          }
 
-            await this.trxMgr.getRepository(InventoryItem).save(foundSerialNumber)
-          } else {
-            let inventoryItem: InventoryItem = new InventoryItem()
-            inventoryItem.name = InventoryNoGenerator.inventoryItemName()
-            inventoryItem.serialNumber = serialNumber
-            inventoryItem.status = INVENTORY_STATUS.PACKING
-            inventoryItem.outboundOrderId = releaseGood.id
-            inventoryItem.source = INVENTORY_ITEM_SOURCE.OUTBOUND
-            inventoryItem.product = product
-            inventoryItem.productDetail = productDetail
-            inventoryItem.inventory = inventory
-            inventoryItem.domain = this.domain
+          if (inventoryItem.outboundOrderId !== releaseGood.id) {
+            throw new Error(`Inventory Item is already picked/packed in ${releaseGood.name}`)
+          }
 
-            await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+          inventoryItem = {
+            ...inventoryItem,
+            status: INVENTORY_STATUS.PACKING,
+            updater: this.user,
+          }
+        } else {
+          inventoryItem = {
+            name: InventoryNoGenerator.inventoryItemName(),
+            serialNumber: serialNumber,
+            status: INVENTORY_STATUS.PACKING,
+            outboundOrderId: releaseGood.id,
+            source: INVENTORY_ITEM_SOURCE.OUTBOUND,
+            product: product,
+            productDetail: productDetail,
+            inventory: inventory,
+            domain: this.domain,
           }
-        }
-      }
 
-      targetInventory.packedQty = Boolean(targetInventory?.packedQty)
-        ? targetInventory.packedQty + packedQty
-        : packedQty
-      if (targetInventory.packedQty > pickedQty) {
-        throw new Error(
-          this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`)
-        )
+        }
       }
 
-      targetInventory.packedAt = new Date()
-      targetInventory.packedByUser = this.user
-
-      let packedBy: string[] = targetInventory.packedBy ? targetInventory.packedBy.split(',') : []
+      // set orderInventory Value
+      orderInventory.packedQty = (orderInventory?.packedQty || 0) + packedQty
+      orderInventory.packedAt = new Date()
+      let packedBy: string[] = orderInventory.packedBy ? orderInventory.packedBy.split(',') : []
       if (!packedBy.find(x => x == this.user.name)) {
         packedBy.push(this.user.name)
-        targetInventory.packedBy = packedBy.join(',')
+        orderInventory.packedBy = packedBy.join(',')
       }
 
-      if (targetInventory.packedQty == pickedQty) {
-        targetInventory.status = ORDER_INVENTORY_STATUS.PACKED
-        await this.updateOrderTargets([targetInventory])
-        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+      // set orderPackageItem Value
+      let updateOrderPackageItem: Partial<OrderPackageItem> = {
+        packedQty: (orderPackageItem?.packedQty || 0) + packedQty,
+        updatedAt: new Date(),
+        updater: this.user
+      }
+      if (updateOrderPackageItem.packedQty === orderPackageItem.releaseQty) {
+        updateOrderPackageItem.status = ORDER_STATUS.DONE
+      }
 
-        worksheetDetail.status = WORKSHEET_STATUS.DONE
-        worksheetDetail.updater = this.user
-        await this.trxMgr.getRepository(WorksheetDetail).save(worksheetDetail)
+      if (inventoryItem) {
+        await this.trxMgr.getRepository(InventoryItem).save(inventoryItem)
+      }
+      orderInventory = (await this.updateOrderTargets([orderInventory]))[0]
 
-        let inventoryItems: InventoryItem = await this.trxMgr
-          .getRepository(InventoryItem)
-          .find({ where: { outboundOrderId: releaseGood.id } })
+      await this.trxMgr.getRepository(OrderPackageItem).update({ id: orderPackageItem.id }, updateOrderPackageItem)
+      updateOrderPackageItem = await this.trxMgr.getRepository(OrderPackageItem).findOne({ where: { id: orderPackageItem.id } })
 
-        if (inventoryItems.length > 0) {
-          inventoryItems.forEach((itm: InventoryItem) => {
-            itm.status = INVENTORY_STATUS.PACKED
-            itm.updater = this.user
-          })
+      await this.trxMgr.getRepository(OrderPackage).update({ id: orderPackageItem.orderPackageId }, { updatedAt: new Date(), updater: this.user })
 
-          await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
-        }
-      } else {
-        await this.trxMgr.getRepository(OrderInventory).save(targetInventory)
-      }
-      break
-    }
-
-    orderPackageItem.packedQty = Boolean(orderPackageItem?.packedQty)
-      ? orderPackageItem.packedQty + packedQty
-      : packedQty
+      if (orderInventory.packedQty === releaseQty) {
+        orderInventory.status = ORDER_INVENTORY_STATUS.PACKED
+        await this.transactionInventory(inventory, releaseGood, 0, 0, INVENTORY_TRANSACTION_TYPE.PACKING)
+        await this.trxMgr.getRepository(WorksheetDetail).update({ targetInventory: { id: orderInventory.id }, type: 'PACKING' },
+          {
+            status: WORKSHEET_STATUS.DONE,
+            updater: this.user,
+            updatedAt: new Date()
+          }
+        )
 
-    if (orderPackageItem.packedQty == orderPackageItem.releaseQty) {
-      orderPackageItem.status = ORDER_STATUS.DONE
-    } else if (orderPackageItem.packedQty > orderPackageItem.releaseQty) {
-      throw new Error(this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY('pack', `packed quantity can't exceed release qty`))
-    }
+        //// update related inventoryItems related with the releaseOrder
+        await this.trxMgr.getRepository(InventoryItem).update({ outboundOrderId: releaseGood.id },
+          {
+            status: INVENTORY_STATUS.PACKED,
+            updater: this.user,
+            updatedAt: new Date()
+          }
+        )
+      }
 
-    await this.trxMgr.getRepository(OrderPackageItem).save(orderPackageItem)
-    await this.trxMgr
-      .getRepository(OrderPackage)
-      .update({ id: orderPackageItem.orderPackage.id }, { updatedAt: new Date() })
 
-    return {
-      worksheetDetailInfos: [
-        {
-          id: orderPackageItem.id,
-          releaseQty: orderPackageItem.releaseQty,
-          packedQty: orderPackageItem.packedQty,
-          status: orderPackageItem.status
-        }
-      ]
+      return {
+        worksheetDetailInfos: [
+          {
+            id: updateOrderPackageItem.id,
+            releaseQty: updateOrderPackageItem.releaseQty,
+            packedQty: updateOrderPackageItem.packedQty,
+            status: updateOrderPackageItem.status
+          }
+        ]
+      }
+    } catch (error) {
+      throw error
     }
   }
 
@@ -484,9 +462,7 @@ export class PackingWorksheetController extends VasWorksheetController {
       .getRepository(OrderPackage)
       .findOne({ where: { id: orderPackageId } })
 
-    await this.trxMgr
-      .getRepository(OrderPackage)
-      .update({ id: orderPackage.id }, { status: ORDER_STATUS.DONE, updater: this.user, updatedAt: new Date() })
+    await this.trxMgr.getRepository(OrderPackage).update({ id: orderPackage.id }, { status: ORDER_STATUS.DONE, updater: this.user, updatedAt: new Date() })
 
     let releaseGood: ReleaseGood = await this.findRefOrder(
       ReleaseGood,
@@ -504,14 +480,10 @@ export class PackingWorksheetController extends VasWorksheetController {
     ])
     this.checkRecordValidity(worksheet, { status: WORKSHEET_STATUS.EXECUTING })
 
-    let orderPackages: OrderPackage[] = await this.trxMgr
-      .getRepository(OrderPackage)
-      .find({ where: { releaseGood, domain: this.domain, bizplace: releaseGood.bizplace } })
+    let orderPackages: OrderPackage[] = await this.trxMgr.getRepository(OrderPackage).find({ where: { releaseGood, domain: this.domain, bizplace: releaseGood.bizplace } })
 
     if (orderPackages.every(op => op.status == ORDER_STATUS.DONE)) {
-      let inventoryItems: InventoryItem = await this.trxMgr
-        .getRepository(InventoryItem)
-        .find({ where: { outboundOrderId: releaseGood.id } })
+      let inventoryItems: InventoryItem = await this.trxMgr.getRepository(InventoryItem).find({ where: { outboundOrderId: releaseGood.id } })
 
       if (inventoryItems.length > 0) {
         inventoryItems.forEach((itm: InventoryItem) => {
@@ -526,6 +498,14 @@ export class PackingWorksheetController extends VasWorksheetController {
       if (releaseGood?.courierOption) orderStatus = ORDER_STATUS.DONE
       else orderStatus = ORDER_STATUS.LOADING
 
+      //update releaseGood TrackingNo
+      if (orderPackage.trackingNo && releaseGood) {
+        await this.trxMgr.getRepository(ReleaseGood).update(
+          { id: releaseGood.id },
+          { trackingNo: `${releaseGood?.trackingNo ? releaseGood?.trackingNo.split(',').push(orderPackage.trackingNo).join(',') : orderPackage.trackingNo}` }
+        )
+      }
+
       return await this.completeWorksheet(worksheet, orderStatus)
     } else {
       return worksheet

package/server/controllers/worksheet-controller.ts

@@ -416,7 +416,7 @@ export class WorksheetController {
     let existingWorksheet: Worksheet
     try {
       existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
-    } catch (e) {}
+    } catch (e) { }
 
     if (existingWorksheet)
       throw new Error(

package/server/graphql/resolvers/worksheet/packing/scan-product-packing.ts

@@ -1,5 +1,7 @@
 import { EntityManager } from 'typeorm'
 
+const { PerformanceObserver, performance } = require('node:perf_hooks');
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 
@@ -20,7 +22,7 @@ export async function scanProductPacking(
   productBarcode: string,
   serialNumber?: string
 ) {
-  console.time(`execution time to scan for packing ${orderPackageItemId} - ${productBarcode}`)
+  performance.mark(`start:${orderPackageItemId} - ${productBarcode}`)
   try {
     const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
     const inventoryItems = await worksheetController.scanProductPacking(
@@ -29,10 +31,12 @@ export async function scanProductPacking(
       serialNumber
     )
 
-    console.timeEnd(`execution time to scan for packing ${orderPackageItemId} - ${productBarcode}`)
     return inventoryItems
   } catch (error) {
-    console.timeEnd(`execution time to scan for packing ${orderPackageItemId} - ${productBarcode}`)
     throw error
+  } finally {
+    performance.mark(`end:${orderPackageItemId} - ${productBarcode}`)
+    let perf = performance.measure(`scanProductPacking: ${orderPackageItemId} - ${productBarcode}`, `start:${orderPackageItemId} - ${productBarcode}`, `end:${orderPackageItemId} - ${productBarcode}`)
+    console.info(perf.toJSON())
   }
 }

package/server/utils/lmd-util.ts

@@ -20,7 +20,7 @@ export async function createLmdParcel(releaseGoods, tx) {
   try {
     let parcelsRequest = []
     for (let releaseGood of releaseGoods) {
-      const lmd: LastMileDelivery = releaseGood.lastMileDelivery
+      let lmd: LastMileDelivery = releaseGood.lastMileDelivery
 
       const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
         where: { domain: releaseGood.domain },
@@ -38,7 +38,8 @@ export async function createLmdParcel(releaseGoods, tx) {
         if(lmd?.platform=='NINJA_VAN'){
           const currentTimestamp: number = Math.floor(Date.now() / 1000)
           if (currentTimestamp >= lmd?.expiresIn) {
-            await refreshAccessTokenNinjavan(lmd?.id,{state:{  tx }})
+            const lastMileDelivery= await refreshAccessTokenNinjavan(lmd?.id,{state:{  tx }})
+            lmd.accessToken=lastMileDelivery.accessToken
         }
       }