@things-factory/worksheet-base 4.3.282 → 4.3.284

package/server/graphql/resolvers/worksheet/picking/complete-batch-picking.ts

@@ -41,14 +41,16 @@ export const completeBatchPickingResolver = {
     if (obsolete) {
       return { obsolete: true }
     }
-    const bizplace: Bizplace = await getMyBizplace(domain, user)
-    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
-    await worksheetController.notifyToCustomer(bizplace, {
-      title: `Picking has been completed (${bizplace.name}, ${taskNo})`,
-      body: `Items now are ready for sorting`,
-      url: context.header.referer,
-      data: { url: context.header.referer }
-    })
+
+    // disabled notification to users due to performance issue by @ChrisLim-git 
+    // const bizplace: Bizplace = await getMyBizplace(domain, user)
+    // const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+    // await worksheetController.notifyToCustomer(bizplace, {
+    //   title: `Picking has been completed (${bizplace.name}, ${taskNo})`,
+    //   body: `Items now are ready for sorting`,
+    //   url: context.header.referer,
+    //   data: { url: context.header.referer }
+    // })
   }
 }
 
@@ -58,31 +60,36 @@ export async function completeBatchPicking(
   user: User,
   taskNo: string
 ): Promise<any> {
-  const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
-
-  if (worksheet?.type) {
-    const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
-    const targetInventories: OrderInventory[] = worksheetDetails
-      .filter(wsd => wsd.status != 'MISSING' && wsd.status != 'CANCELLED')
-      .map((wsd: WorksheetDetail) => wsd.targetInventory)
-
-    const releaseGoods: ReleaseGood[] = worksheetDetails.map(
-      worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
-    )
-
-    const uniqueReleaseGoods: ReleaseGood[] = []
-    const map = new Map()
-    for (const releaseGood of releaseGoods) {
-      if (!map.has(releaseGood.id)) {
-        map.set(releaseGood.id, true)
-        uniqueReleaseGoods.push({ ...releaseGood })
+  try {
+    console.time(`complete-batch-picking[completeBatchPicking]: {domain:${domain.id}, taskNo:${taskNo}}`)
+
+    const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    const worksheet = await pickingWSCtrl.completeBatchPicking(taskNo)
+
+    if (worksheet?.type) {
+      const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
+      const targetInventories: OrderInventory[] = worksheetDetails
+        .filter(wsd => wsd.status != 'MISSING' && wsd.status != 'CANCELLED')
+        .map((wsd: WorksheetDetail) => wsd.targetInventory)
+
+      const releaseGoods: ReleaseGood[] = worksheetDetails.map(
+        worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
+      )
+
+      let uniqueReleaseGoods: ReleaseGood[] = []
+      const map = new Map()
+
+      // remove any duplicated releaseGoods
+      for (const releaseGood of releaseGoods) {
+        if (!map.has(releaseGood.id)) {
+          map.set(releaseGood.id, true)
+          uniqueReleaseGoods.push({ ...releaseGood })
+        }
       }
-    }
 
-    for (let i = 0; i < uniqueReleaseGoods.length; i++) {
-      let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-        where: { id: uniqueReleaseGoods[i].id },
+      // fetch all release goods in 1 go
+      uniqueReleaseGoods = await tx.getRepository(ReleaseGood).find({
+        where: { id: In(uniqueReleaseGoods.map(rg => rg.id)) },
         relations: [
           'domain',
           'creator',
@@ -102,265 +109,265 @@ export async function completeBatchPicking(
           'bizplace.company.domain'
         ]
       })
-      const orderSource: string = foundReleaseGood.source
-      switch (orderSource) {
-        case ApplicationType.SELLERCRAFT:
-          const sellercraft: Sellercraft = await tx
-            .getRepository(Sellercraft)
-            .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
-
-          if (sellercraft) {
-            const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
-              await getManager().transaction(async txMgr => {
-                const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
-
-                if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
-                  await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
-                }
 
-                const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
-                  where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+      // Integration triggers
+      for (let i = 0; i < uniqueReleaseGoods.length; i++) {
+        let foundReleaseGood: ReleaseGood = uniqueReleaseGoods[i]
+
+        const orderSource: string = foundReleaseGood.source
+        switch (orderSource) {
+          case ApplicationType.SELLERCRAFT:
+            const sellercraft: Sellercraft = await tx
+              .getRepository(Sellercraft)
+              .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+            if (sellercraft) {
+              const initSCOrderShipment = async (sellercraft: Sellercraft, foundReleaseGood: ReleaseGood) => {
+                await getManager().transaction(async txMgr => {
+                  const sellercraftCtrl: SellercraftController = new SellercraftController(txMgr, domain, user)
+
+                  if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
+                    await sellercraftCtrl.packOrder(sellercraft, foundReleaseGood)
+                  }
+
+                  const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                    where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+                  })
+
+                  if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                    await sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
+                  }
                 })
+              }
 
-                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                  await sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
-                }
-              })
+              // asynchronouly call to initiate sellercraft order shipment/ RTS
+              initSCOrderShipment(sellercraft, foundReleaseGood)
             }
+            break
 
-            // asynchronouly call to initiate sellercraft order shipment/ RTS
-            initSCOrderShipment(sellercraft, foundReleaseGood)
-          }
-          break
+          case ApplicationType.POWRUP:
+            const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
 
-        case ApplicationType.POWRUP:
-          const powrup: Powrup = await tx.getRepository(Powrup).findOne({ active: true, platform: 'POWRUP' })
+            if (powrup) {
+              const initPowrupShipment = async (powrup: Powrup, foundReleaseGood: ReleaseGood) => {
+                await getManager().transaction(async txMgr => {
+                  const powrupCtrl: PowrupController = new PowrupController()
 
-          if (powrup) {
-            const initPowrupShipment = async (powrup: Powrup, foundReleaseGood: ReleaseGood) => {
-              await getManager().transaction(async txMgr => {
-                const powrupCtrl: PowrupController = new PowrupController()
+                  if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
+                    await powrupCtrl.packOrder(powrup, foundReleaseGood, domain, user, txMgr)
+                  }
 
-                if (!foundReleaseGood?.orderPackages?.length && !foundReleaseGood?.marketPackCallSuccess) {
-                  await powrupCtrl.packOrder(powrup, foundReleaseGood, domain, user, txMgr)
-                }
+                  const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
+                    where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+                  })
 
-                const rtsTriggerLevel: Setting = await txMgr.getRepository(Setting).findOne({
-                  where: { domain, category: 'id-rule', name: 'rts-trigger-level' }
+                  if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                    await powrupCtrl.initiateShipment(powrup, foundReleaseGood, domain, user, txMgr)
+                  }
                 })
+              }
 
-                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                  await powrupCtrl.initiateShipment(powrup, foundReleaseGood, domain, user, txMgr)
-                }
-              })
+              // asynchronouly call to initiate sellercraft order shipment/ RTS
+              initPowrupShipment(powrup, foundReleaseGood)
             }
+            break
+
+          case ApplicationType.MMS:
+            const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
+            const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+              where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
+              relations: [
+                'marketplaceOrderItems',
+                'marketplaceOrderItems.marketplaceOrderShippingItems',
+                'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+                'marketplaceStore',
+                'marketplaceStore.marketplaceDistributors'
+              ]
+            })
+            const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
 
-            // asynchronouly call to initiate sellercraft order shipment/ RTS
-            initPowrupShipment(powrup, foundReleaseGood)
-          }
-          break
-
-        case ApplicationType.MMS:
-          const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
-            relations: [
-              'marketplaceOrderItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-              'marketplaceStore',
-              'marketplaceStore.marketplaceDistributors'
-            ]
-          })
-          const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-
-          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-          if (marketplaceStore?.isAutoUpdateShipment) {
-            await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
-          }
-          foundReleaseGood = await ecommerceCtrl.createOrderPackage(
-            tx,
-            marketplaceOrder,
-            companyDomain,
-            marketplaceStore,
-            foundReleaseGood
-          )
-          break
-
-        default:
-          let orderPackage: OrderPackage = {
-            name: OrderNoGenerator.orderPackage(),
-            packageId: null,
-            trackingNo: null,
-            transporter: null,
-            airwayBill: null,
-            status: ORDER_STATUS.PROCESSING,
-            releaseGood: foundReleaseGood,
-            domain: foundReleaseGood.domain,
-            bizplace: foundReleaseGood.bizplace,
-            creator: foundReleaseGood.creator,
-            updater: foundReleaseGood.updater
-          }
-
-          let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
-          const orderPackageItems: OrderPackageItem[] = foundReleaseGood.orderProducts.map(op => {
-            return {
-              name: OrderNoGenerator.orderPackageItem(),
-              orderProduct: op,
+            const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+            if (marketplaceStore?.isAutoUpdateShipment) {
+              await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+            }
+            foundReleaseGood = await ecommerceCtrl.createOrderPackage(
+              tx,
+              marketplaceOrder,
+              companyDomain,
+              marketplaceStore,
+              foundReleaseGood
+            )
+            break
+
+          default:
+            let orderPackage: OrderPackage = {
+              name: OrderNoGenerator.orderPackage(),
+              packageId: null,
+              trackingNo: null,
+              transporter: null,
+              airwayBill: null,
               status: ORDER_STATUS.PROCESSING,
-              releaseQty: op.releaseQty,
-              orderPackage: savedOrderPackage,
+              releaseGood: foundReleaseGood,
               domain: foundReleaseGood.domain,
               bizplace: foundReleaseGood.bizplace,
               creator: foundReleaseGood.creator,
               updater: foundReleaseGood.updater
             }
-          })
 
-          await tx.getRepository(OrderPackageItem).save(orderPackageItems)
-          orderPackage.orderPackageItems = orderPackageItems
-          foundReleaseGood.orderPackages = [orderPackage]
-          break
-      }
+            let savedOrderPackage: OrderPackage = await tx.getRepository(OrderPackage).save(orderPackage)
+            const orderPackageItems: OrderPackageItem[] = foundReleaseGood.orderProducts.map(op => {
+              return {
+                name: OrderNoGenerator.orderPackageItem(),
+                orderProduct: op,
+                status: ORDER_STATUS.PROCESSING,
+                releaseQty: op.releaseQty,
+                orderPackage: savedOrderPackage,
+                domain: foundReleaseGood.domain,
+                bizplace: foundReleaseGood.bizplace,
+                creator: foundReleaseGood.creator,
+                updater: foundReleaseGood.updater
+              }
+            })
 
-      const account: Account = await tx
-        .getRepository(Account)
-        .findOne({ where: { domain: foundReleaseGood.bizplace.domain, status: 'active' }, relations: ['domain'] })
-
-      // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
-      const createSalesOrder = async (account, releaseGood, tx) => {
-        if (account) {
-          if (account.platform == 'xilnex') {
-            try {
-              delete releaseGood.orderPackages
-              delete releaseGood.creator
-              delete releaseGood.updater
-
-              const body = {
-                accessToken: account.accessToken,
-                appId: account.accountId,
-                accountInfo: account.accountInfo,
-                req: JSON.stringify({
-                  releaseGood,
-                  orderProducts: releaseGood.orderProducts
+            await tx.getRepository(OrderPackageItem).save(orderPackageItems)
+            orderPackage.orderPackageItems = orderPackageItems
+            foundReleaseGood.orderPackages = [orderPackage]
+            break
+        }
+
+        const account: Account = await tx
+          .getRepository(Account)
+          .findOne({ where: { domain: foundReleaseGood.bizplace.domain, status: 'active' }, relations: ['domain'] })
+
+        // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
+        const createSalesOrder = async (account, releaseGood, tx) => {
+          if (account) {
+            if (account.platform == 'xilnex') {
+              try {
+                delete releaseGood.orderPackages
+                delete releaseGood.creator
+                delete releaseGood.updater
+
+                const body = {
+                  accessToken: account.accessToken,
+                  appId: account.accountId,
+                  accountInfo: account.accountInfo,
+                  req: JSON.stringify({
+                    releaseGood,
+                    orderProducts: releaseGood.orderProducts
+                  })
+                }
+
+                await sqsSendMessage({
+                  body,
+                  deduplicationId: releaseGood.refNo,
+                  groupId: releaseGood.refNo,
+                  queueName: 'prototypeQueue.fifo'
                 })
+              } catch (e) {
+                throw new Error(e)
               }
-
-              await sqsSendMessage({
-                body,
-                deduplicationId: releaseGood.refNo,
-                groupId: releaseGood.refNo,
-                queueName: 'prototypeQueue.fifo'
-              })
-            } catch (e) {
-              throw new Error(e)
             }
           }
         }
-      }
 
-      if (foundReleaseGood.type == 'b2c') {
-        createSalesOrder(account, foundReleaseGood, tx)
-      }
+        if (foundReleaseGood.type == 'b2c') {
+          createSalesOrder(account, foundReleaseGood, tx)
+        }
 
-      // trigger LMD API to create parcel
-      if (
-        foundReleaseGood?.orderPackages?.length &&
-        foundReleaseGood.lmdOption &&
-        foundReleaseGood.lastMileDelivery &&
-        foundReleaseGood?.orderPackages?.some(op => op.parcelId == null)
-      ) {
-        await createLmdParcel([foundReleaseGood], tx)
-        // trigger RTS
-        try {
-          const orderSource: string = foundReleaseGood.source
-
-          if (orderSource == ApplicationType.SELLERCRAFT) {
-            const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-              domain: foundReleaseGood.bizplace.domain,
-              status: SellercraftStatus.ACTIVE
-            })
-            if (sellercraft) {
-              const sellercraftCtrl: SellercraftController = new SellercraftController(tx, null, null)
-              const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
-                where: { domain: foundReleaseGood.domain, category: 'id-rule', name: 'rts-trigger-level' }
+        // trigger LMD API to create parcel
+        if (
+          foundReleaseGood?.orderPackages?.length &&
+          foundReleaseGood.lmdOption &&
+          foundReleaseGood.lastMileDelivery &&
+          foundReleaseGood?.orderPackages?.some(op => op.parcelId == null)
+        ) {
+          await createLmdParcel([foundReleaseGood], tx)
+          // trigger RTS
+          try {
+            const orderSource: string = foundReleaseGood.source
+
+            if (orderSource == ApplicationType.SELLERCRAFT) {
+              const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+                domain: foundReleaseGood.bizplace.domain,
+                status: SellercraftStatus.ACTIVE
               })
+              if (sellercraft) {
+                const sellercraftCtrl: SellercraftController = new SellercraftController(tx, null, null)
+                const rtsTriggerLevel: Setting = await tx.getRepository(Setting).findOne({
+                  where: { domain: foundReleaseGood.domain, category: 'id-rule', name: 'rts-trigger-level' }
+                })
 
-              if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
-                sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
+                if (rtsTriggerLevel && parseInt(rtsTriggerLevel?.value || 0) == 1) {
+                  sellercraftCtrl.initiateOrderShipment(sellercraft, foundReleaseGood)
+                }
               }
             }
+          } catch (e) {
+            logger.error(`[get-lmd-awb-sof-trigger]: ${e}`)
           }
-        } catch (e) {
-          logger.error(`[get-lmd-awb-sof-trigger]: ${e}`)
+          //
         }
         //
       }
-      //
-    }
-
-    const pickPackTargetInventories: OrderInventory[] = targetInventories
-      .filter(targetInventory => targetInventory.releaseGood.packingOption)
-      .map((pickPackTargetInventory: OrderInventory) => {
-        return pickPackTargetInventory
-      })
-
-    const pickSortTargetInventories: OrderInventory[] = targetInventories
-      .filter(targetInventory => !targetInventory.releaseGood.packingOption)
-      .map((pickSortTargetInventory: OrderInventory) => {
-        return pickSortTargetInventory
-      })
-
-    if (pickPackTargetInventories?.length) {
-      // pull out all unique RO
-      const roNoList: string[] = pickPackTargetInventories.map((oi: OrderInventory) => oi.releaseGood.name)
-      let uniqueRoNo: string[] = []
-      roNoList.forEach(roNo => {
-        if (!uniqueRoNo.includes(roNo)) {
-          uniqueRoNo.push(roNo)
-        }
-      })
 
-      // loop to generate packing worksheet
-      for (let i: number = 0; i < uniqueRoNo.length; i++) {
-        const releaseGoodNo: string = uniqueRoNo[i]
+      // generate packing worksheet based on orders WITH packing option
+      const pickPackOrders: ReleaseGood[] = uniqueReleaseGoods.filter(rg => rg.packingOption)
 
+      if (pickPackOrders?.length) {
+        const roNoList: string[] = pickPackOrders.map((rg: ReleaseGood) => rg.name)
         const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-        await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+        await packingWSCtrl.generatePackingWorksheetByBulk(roNoList)
       }
-    }
 
-    // loop to generate sorting worksheet
-    if (pickSortTargetInventories?.length) {
-      const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-      await sortingWSCtrl.generateSortingWorksheet(worksheet, pickSortTargetInventories)
-    }
-  } else {
-    let foundObsoleteInventories: any = worksheet
-    await tx.getRepository(Inventory).update({ id: In(foundObsoleteInventories) }, { obsolete: true })
+      // generate packing worksheet with orderInventory based on orders WITHOUT packing option
+      const pickSortTargetInventories: OrderInventory[] = targetInventories
+        .filter(targetInventory => !targetInventory.releaseGood.packingOption)
+        .map((pickSortTargetInventory: OrderInventory) => {
+          return pickSortTargetInventory
+        })
+
+      // loop to generate sorting worksheet
+      if (pickSortTargetInventories?.length) {
+        const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
+        await sortingWSCtrl.generateSortingWorksheet(worksheet, pickSortTargetInventories)
+      }
 
-    foundObsoleteInventories = foundObsoleteInventories
-      .map(inv => {
-        return "'" + inv.trim() + "'"
-      })
-      .join(',')
-
-    //update any orders that is assigned with obsolete inventories
-    await tx.getRepository(ReleaseGood).query(`
-    update release_goods rg set status = 'OBSOLETE' 
-    from order_inventories oi
-    where oi.release_good_id = rg.id
-    and oi.inventory_id in (${foundObsoleteInventories})
-    and rg.status in ('PICKING', 'PENDING_WORKSHEET', 'READY_TO_PICK')`)
-
-    await tx.getRepository(Worksheet).query(`
-    update worksheets w set status = 'DEACTIVATED', updater_id = '${user.id}', assignee_id = null
-    from worksheet_details wd
-    inner join order_inventories oi on oi.id = wd.target_inventory_id
-    where wd.worksheet_id = w.id
-    and oi.inventory_id in (${foundObsoleteInventories})
-    `)
-
-    return true
+      return false
+    } else {
+      let foundObsoleteInventories: any = worksheet
+      await tx.getRepository(Inventory).update({ id: In(foundObsoleteInventories) }, { obsolete: true })
+
+      foundObsoleteInventories = foundObsoleteInventories
+        .map(inv => {
+          return "'" + inv.trim() + "'"
+        })
+        .join(',')
+
+      //update any orders that is assigned with obsolete inventories
+      await tx.getRepository(ReleaseGood).query(`
+        update release_goods rg set status = 'OBSOLETE' 
+        from order_inventories oi
+        where oi.release_good_id = rg.id
+        and oi.inventory_id in (${foundObsoleteInventories})
+        and rg.status in ('PICKING', 'PENDING_WORKSHEET', 'READY_TO_PICK')
+      `)
+
+      await tx.getRepository(Worksheet).query(`
+        update worksheets w set status = 'DEACTIVATED', updater_id = '${user.id}', assignee_id = null
+        from worksheet_details wd
+        inner join order_inventories oi on oi.id = wd.target_inventory_id
+        where wd.worksheet_id = w.id
+        and oi.inventory_id in (${foundObsoleteInventories})
+      `)
+
+      return true
+    }
+  } catch (error) {
+    logger.error(error)
+    throw error
+  } finally {
+    console.timeEnd(`complete-batch-picking[completeBatchPicking]: {domain:${domain.id}, taskNo:${taskNo}}`)
   }
+
 }

package/server/utils/inventory-util.ts

@@ -146,7 +146,7 @@ export async function inventoriesByStrategy(
     })
     .andWhere('"INV"."obsolete" = false')
     .andWhere(
-      'case when "INV"."expiration_date" is not null and "PROD"."shelf_life" is not null then CURRENT_DATE < "INV"."expiration_date" - "PROD"."shelf_life" else true end'
+      'case when "INV"."expiration_date" is not null and "PROD"."min_outbound_shelf_life" is not null then CURRENT_DATE < "INV"."expiration_date" - "PROD"."min_outbound_shelf_life" else true end'
     )
     .setParameters({
       domainId: domain.id,

package/server/utils/lmd-util.ts

@@ -6,7 +6,7 @@ import { Bizplace } from '@things-factory/biz-base'
 import { Board, headlessModel, pdf } from '@things-factory/board-service'
 import { logger } from '@things-factory/env'
 import { GeoArea } from '@things-factory/geography'
-import { LastMileAPI, LastMileDelivery } from '@things-factory/integration-lmd'
+import { LastMileAPI, LastMileDelivery, refreshAccessTokenNinjavan} from '@things-factory/integration-lmd'
 import { OrderPackage, ReleaseGood } from '@things-factory/sales-base'
 
 // import { SellercraftController } from '../controllers'
@@ -35,6 +35,13 @@ export async function createLmdParcel(releaseGoods, tx) {
         .getRepository(GeoArea)
         .findOne({ where: { postalCode: releaseGood.postalCode } })
 
+        if(lmd?.platform=='NINJA_VAN'){
+          const currentTimestamp: number = Math.floor(Date.now() / 1000)
+          if (currentTimestamp >= lmd?.expiresIn) {
+            await refreshAccessTokenNinjavan(lmd?.id,{state:{  tx }})
+        }
+      }
+
       let data = {
         courier: lmd.platform,
         clientId: lmd?.clientId,