@things-factory/worksheet-base 4.3.823 → 4.3.825

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

@@ -1,11 +1,11 @@
-import { EntityManager, Equal, getConnection, getManager, In, IsNull, Not } from 'typeorm'
+import { EntityManager, Equal, getManager, In, IsNull, Not } from 'typeorm'
 import { v4 as uuidv4 } from 'uuid'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
 import { generateId } from '@things-factory/id-rule-base'
-import { Powrup } from '@things-factory/integration-powrup'
+import { notifyPowrupOrderStatus, Powrup } from '@things-factory/integration-powrup'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { Product, ProductDetail } from '@things-factory/product-base'
 import {
@@ -436,6 +436,9 @@ export class PickingWorksheetController extends VasWorksheetController {
     }
 
     webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.PickingStarted)
+    if (releaseGood.source === ApplicationType.POWRUP) {
+      notifyPowrupOrderStatus(releaseGood, 'PICKING', worksheet.startedAt)
+    }
 
     if (newReleaseGood) {
       worksheet.releaseGood = newReleaseGood
@@ -722,6 +725,9 @@ export class PickingWorksheetController extends VasWorksheetController {
 
     for (const releaseGood of releaseGoods) {
       webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.PickingStarted)
+      if (releaseGood.source === ApplicationType.POWRUP) {
+        notifyPowrupOrderStatus(releaseGood, 'PICKING', worksheet.startedAt)
+      }
     }
 
     return worksheet
@@ -1108,9 +1114,6 @@ export class PickingWorksheetController extends VasWorksheetController {
         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
@@ -1141,78 +1144,72 @@ export class PickingWorksheetController extends VasWorksheetController {
         .execute()
 
       if (oiUpdateResult.affected > 0 && targetInventory.pickedQty == releaseQty) {
-        getConnection().transaction(async (tx: EntityManager) => {
-          try {
-            //update worksheet details only when line item picking complete
-            await tx
-              .getRepository(WorksheetDetail)
-              .createQueryBuilder()
-              .update(WorksheetDetail)
-              .set({
-                status: WORKSHEET_STATUS.DONE,
-                updater: this.user,
-                updatedAt: new Date()
-              })
-              .where('id = :id', { id: worksheetDetailInfos.worksheetDetailId })
-              .execute()
+        //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: worksheetDetailInfos.worksheetDetailId })
+          .execute()
 
-            let releaseUomValue = Math.trunc((pickedUomValue / pickedQty) * releaseQty * 1000) / 1000
+        let releaseUomValue = Math.trunc((pickedUomValue / pickedQty) * releaseQty * 1000) / 1000
 
-            let updateInvObj = {
-              qty: () => `"qty" - :deductQty::numeric`,
-              lockedQty: () => `GREATEST("locked_qty" - :deductQty::numeric, 0)`,
-              uomValue: () => `"uom_value" - :deductUomValue::numeric`,
-              lockedUomValue: () => `GREATEST("locked_uom_value" - :deductUomValue::numeric, 0)`,
-              status: () =>
-                `case when "qty" - :deductQty::numeric <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
-              updater: this.user,
-              updatedAt: new Date()
-            }
+        let updateInvObj = {
+          qty: () => `"qty" - :deductQty::numeric`,
+          lockedQty: () => `GREATEST("locked_qty" - :deductQty::numeric, 0)`,
+          uomValue: () => `"uom_value" - :deductUomValue::numeric`,
+          lockedUomValue: () => `GREATEST("locked_uom_value" - :deductUomValue::numeric, 0)`,
+          status: () =>
+            `case when "qty" - :deductQty::numeric <= 0 then '${INVENTORY_STATUS.TERMINATED}' else status end`,
+          updater: this.user,
+          updatedAt: new Date()
+        }
 
-            const invUpdateResult = await tx
-              .getRepository(Inventory)
-              .createQueryBuilder()
-              .update(Inventory)
-              .set(updateInvObj)
-              .setParameter('deductQty', releaseQty)
-              .setParameter('deductUomValue', releaseUomValue)
-              .where('id = :id AND qty >= :deductQty', {
-                id: worksheetDetailInfos.inventoryId,
-                deductQty: releaseQty
-              })
-              .returning(['qty'])
-              .execute()
+        const invUpdateResult = await this.trxMgr
+          .getRepository(Inventory)
+          .createQueryBuilder()
+          .update(Inventory)
+          .set(updateInvObj)
+          .setParameter('deductQty', releaseQty)
+          .setParameter('deductUomValue', releaseUomValue)
+          .where('id = :id AND qty >= :deductQty', {
+            id: worksheetDetailInfos.inventoryId,
+            deductQty: releaseQty
+          })
+          .returning(['qty'])
+          .execute()
 
-            if (invUpdateResult.affected === 0) {
-              throw new Error(`Insufficient inventory quantity to complete picking`)
-            }
+        if (invUpdateResult.affected === 0) {
+          throw new Error(`Insufficient inventory quantity to complete picking`)
+        }
 
-            await generateInventoryHistory(
-              inventory,
-              releaseGood,
-              INVENTORY_TRANSACTION_TYPE.PICKING,
-              -releaseQty,
-              -releaseUomValue,
-              this.user,
-              tx
-            )
+        await generateInventoryHistory(
+          inventory,
+          releaseGood,
+          INVENTORY_TRANSACTION_TYPE.PICKING,
+          -releaseQty,
+          -releaseUomValue,
+          this.user,
+          this.trxMgr
+        )
 
-            let inventoryItems: InventoryItem = await tx
-              .getRepository(InventoryItem)
-              .find({ where: { outboundOrderId: worksheetDetailInfos.releaseGoodId } })
+        let inventoryItems: InventoryItem[] = await this.trxMgr
+          .getRepository(InventoryItem)
+          .find({ where: { outboundOrderId: worksheetDetailInfos.releaseGoodId } })
 
-            if (inventoryItems.length > 0) {
-              inventoryItems.forEach((itm: InventoryItem) => {
-                itm.status = INVENTORY_STATUS.PICKED
-                itm.updater = this.user
-              })
+        if (inventoryItems.length > 0) {
+          inventoryItems.forEach((itm: InventoryItem) => {
+            itm.status = INVENTORY_STATUS.PICKED
+            itm.updater = this.user
+          })
 
-              await tx.getRepository(InventoryItem).save(inventoryItems)
-            }
-          } catch (error) {
-            throw error
-          }
-        })
+          await this.trxMgr.getRepository(InventoryItem).save(inventoryItems)
+        }
       }
 
       let worksheetDetail = await this.trxMgr
@@ -3128,6 +3125,9 @@ export class PickingWorksheetController extends VasWorksheetController {
           }
 
           webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.PickingStarted)
+          if (releaseGood.source === ApplicationType.POWRUP) {
+            notifyPowrupOrderStatus(releaseGood, 'PICKING', worksheet.startedAt)
+          }
 
           worksheet.releaseGood = newReleaseGood ? newReleaseGood : releaseGood
           updatedWs.push(worksheet)

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

@@ -1,6 +1,8 @@
 import { In, IsNull } from 'typeorm'
 import { v4 as uuidv4 } from 'uuid'
+import { ApplicationType } from '@things-factory/auth-base'
 import { webhookHandler, WebhookEventsEnum } from '@things-factory/integration-base'
+import { notifyPowrupOrderStatus } from '@things-factory/integration-powrup'
 import { Product, ProductBarcode, ProductDetail } from '@things-factory/product-base'
 import {
   ORDER_INVENTORY_STATUS,
@@ -143,6 +145,11 @@ export class SortingWorksheetController extends VasWorksheetController {
       })
 
       await this.trxMgr.getRepository(WorksheetDetail).insert(loadingWorksheetDetails)
+
+      webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.LoadingStarted)
+      if (releaseGood.source === ApplicationType.POWRUP) {
+        notifyPowrupOrderStatus(releaseGood, 'LOADING')
+      }
     }
 
     return savedSortingWorksheet
@@ -700,13 +707,6 @@ export class SortingWorksheetController extends VasWorksheetController {
     worksheet.updater = this.user
     worksheet = await this.trxMgr.getRepository(Worksheet).save(worksheet)
 
-    const releaseGoods: ReleaseGood[] = await this.trxMgr
-      .getRepository(ReleaseGood)
-      .find({ where: { id: In(releaseGoodIds) }, relations: ['domain', 'bizplace'] })
-
-    for (let releaseGood of releaseGoods) {
-      webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.LoadingStarted)
-    }
 
     return worksheet
   }

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

@@ -1,5 +1,4 @@
 import { EntityManager, getManager, In } from 'typeorm'
-import { webhookHandler, WebhookEventsEnum } from '@things-factory/integration-base'
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
@@ -411,7 +410,6 @@ export async function completePicking(
 
               const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
               await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
-              webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.LoadingStarted)
             } else {
               const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
               let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -56,6 +56,15 @@ export const fetchAndAssignPickingTaskResolver = {
 
       if (!worksheet) {
         // update and return updated worksheet id
+        // FOR UPDATE OF ws SKIP LOCKED: under concurrent clicks, two callers
+        // used to SELECT the same row and the second UPDATE would re-evaluate,
+        // find assignee_id no longer NULL, update zero rows, and the user
+        // would see a confusing "no suitable worksheet found" error even
+        // though other unassigned rows existed. SKIP LOCKED makes concurrent
+        // callers pick different rows. `OF ws` scopes the row lock to the
+        // worksheets table only (not the joined release_goods rows). Inner
+        // transaction is independent so the row lock is released as soon as
+        // the UPDATE commits.
         let updatedWorksheets = await getConnection().transaction(async (tx2: EntityManager) => {
           let x = await tx2.getRepository(Worksheet).query(
             `
@@ -65,23 +74,25 @@ export const fetchAndAssignPickingTaskResolver = {
             FROM (
               SELECT ws.id, ws.name, ws.status, ws.release_good_id FROM worksheets ws
               INNER JOIN release_goods rg ON rg.id = ws.release_good_id
-              WHERE 
-              ws.domain_id = $1 AND 
+              WHERE
+              ws.domain_id = $1 AND
               ws.type = 'PICKING'
-              AND ws.status IN ('EXECUTING', 'DEACTIVATED') 
+              AND ws.status IN ('EXECUTING', 'DEACTIVATED')
               AND ws.assignee_id IS NULL
               /*
               (condition is commented as current status in oi not in use)
               AND NOT EXISTS (
                 SELECT count(id) AS "totalPS"
-                FROM order_inventories oi 
+                FROM order_inventories oi
                 WHERE oi.release_good_id = ws.release_good_id AND
                 oi.status = 'PENDING_SPLIT'
-                GROUP BY oi.release_good_id 
+                GROUP BY oi.release_good_id
                 HAVING count(id) > 0
               )
               */
-              ORDER BY rg.release_date, rg.created_at LIMIT 1
+              ORDER BY rg.release_date, rg.created_at
+              LIMIT 1
+              FOR UPDATE OF ws SKIP LOCKED
             ) src where src.id = ws.id
             RETURNING ws.id;
           `,

package/server/graphql/resolvers/worksheet/recommend-putaway-location.ts

@@ -3,12 +3,15 @@ import { getRepository, In } from 'typeorm'
 import { ArrivalNotice, ReturnOrder } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse } from '@things-factory/warehouse-base'
+import { Inventory, Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse, calcVolumeInM3, buildProductDetailLabel } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { isInventoryExpiring } from '../../../utils/inventory-util'
 
+// 10% headroom required when storing — accounts for practical height gaps in shelving
+const HEIGHT_GAP_FACTOR = 0.9 // ONLY FOR RECOMMENDATION LEVEL 4
+
 export const recommendPutawayLocationResolver = {
   async recommendPutawayLocation(
     _: void,
@@ -26,7 +29,8 @@ export const recommendPutawayLocationResolver = {
           'worksheet.returnOrder',
           'targetInventory',
           'targetInventory.inventory',
-          'targetInventory.inventory.product'
+          'targetInventory.inventory.product',
+          'targetInventory.inventory.productDetail'
         ]
       }
     )
@@ -87,6 +91,10 @@ export const recommendPutawayLocationResolver = {
         recommendedLocations = await recommendLocationLevel3(domain, targetWarehouse, optCnt, inventory)
         break
 
+      case 'level 4':
+        recommendedLocations = await recommendLocationLevel4(domain, targetWarehouse, optCnt, inventory)
+        break
+
       default:
         recommendedLocations = await recommendLocationLevel1(domain, targetWarehouse, optCnt)
         break
@@ -404,7 +412,7 @@ export async function recommendLocationLevel3(
 
     // ---------------- EMPTY fallback (same type, ordered by rule) ----------------
     if (recommended.length < optCnt) {
-      const emptyLocations = await getRepository(Location).find({
+      const emptyLocationsAll = await getRepository(Location).find({
         where: {
           domain,
           warehouse,
@@ -415,9 +423,107 @@ export async function recommendLocationLevel3(
         take: optCnt - recommended.length
       })
 
-      recommended.push(...emptyLocations)
+      recommended.push(...emptyLocationsAll)
     }
   }
 
   return recommended.slice(0, optCnt)
 }
+
+export async function recommendLocationLevel4(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number,
+  inventory: Inventory
+): Promise<Location[]> {
+  const allowedTypesInOrder: LOCATION_TYPE[] = [LOCATION_TYPE.STORAGE, LOCATION_TYPE.SHELF, LOCATION_TYPE.FLOOR]
+
+  // --- Step 1: Check all EMPTY locations have volume ---
+  const emptyLocations: Location[] = await getRepository(Location).find({
+    where: {
+      domain,
+      warehouse,
+      status: LOCATION_STATUS.EMPTY,
+      type: In(allowedTypesInOrder)
+    }
+  })
+
+  const missingVolume = emptyLocations.some((loc: Location) => !loc.volume)
+  if (missingVolume) {
+    throw new Error('Please update the Location Master to include volume calculation')
+  }
+
+  // --- Step 2: Check product dimensions and length unit ---
+  const pd = inventory.productDetail
+  if (!pd?.lengthUnit || (pd?.volume == null && (!pd?.width || !pd?.depth || !pd?.height))) {
+    throw new Error(
+      'Missing product dimensions or length unit. Please provide width, depth, height, and length unit for correct volume calculation'
+    )
+  }
+
+  const incomingDetail = buildProductDetailLabel(pd)
+  const incomingLabel = `SKU: ${inventory.product?.sku} ${incomingDetail}`.trim()
+  const incomingVolume: number = calcVolumeInM3(pd, incomingLabel) * (inventory.qty ?? 1)
+
+  // --- Step 3: rule-for-storing-product ---
+  const orderSetting: Setting | undefined = await getRepository(Setting).findOne({
+    where: { domain, name: 'rule-for-storing-product' }
+  })
+
+  let sortLocation: Record<string, 'ASC' | 'DESC'> = {}
+  if (orderSetting?.value) {
+    try {
+      sortLocation = JSON.parse(orderSetting.value)
+    } catch {
+      // ignore malformed setting
+    }
+  }
+
+  // --- Step 4: Check if all empty locations having same volume ---
+  const allSameVolume =
+    emptyLocations.length > 0 && emptyLocations.every((loc: Location) => loc.volume === emptyLocations[0].volume)
+
+  if (allSameVolume) {
+    const usableVolume = emptyLocations[0].volume * HEIGHT_GAP_FACTOR
+    if (incomingVolume > usableVolume) return [] // return early to not recommend any
+  }
+
+  const recommended: Location[] = []
+
+  for (const type of allowedTypesInOrder) {
+    if (recommended.length >= optCnt) break
+
+    const candidates: Location[] = emptyLocations.filter((loc: Location) => loc.type === type)
+    if (candidates.length === 0) continue
+
+    if (allSameVolume) {
+      const sortKeys = Object.keys(sortLocation)
+      const sorted = candidates.sort((a: Location, b: Location) => {
+        for (const key of sortKeys) {
+          const dir = sortLocation[key] === 'DESC' ? -1 : 1
+          if (a[key] < b[key]) return -1 * dir
+          if (a[key] > b[key]) return 1 * dir
+        }
+        return 0
+      })
+      recommended.push(...sorted.slice(0, optCnt - recommended.length))
+      if (recommended.length >= optCnt) break
+    } else {
+      // Sort by least remaining space ASC (usable = volume * 0.9, 10% height gap)
+      const sorted = candidates
+        .map((loc: Location) => {
+          const usableVolume = loc.volume * HEIGHT_GAP_FACTOR
+          const remaining = usableVolume - incomingVolume
+          return { loc, remaining }
+        })
+        .filter(({ remaining }) => remaining >= 0)
+        .sort((a, b) => a.remaining - b.remaining)
+        .map(({ loc }) => loc)
+
+      recommended.push(...sorted.slice(0, optCnt - recommended.length))
+    }
+  }
+
+  return recommended.slice(0, optCnt)
+}
+