@things-factory/worksheet-base 4.3.795 → 4.3.798

package/server/graphql/resolvers/worksheet/delivery-order-by-worksheet.ts

@@ -125,7 +125,8 @@ export const deliveryOrderByWorksheetResolver = {
               fax: releaseOrderDeliverTo.fax || '',
               phone: releaseOrderDeliverTo.phone || '',
               contactName: releaseOrderDeliverTo.name || '',
-              businessRestDay: releaseOrderDeliverTo.businessRestDay || ''
+              businessRestDay: releaseOrderDeliverTo.businessRestDay || '',
+              customerCode: releaseOrderDeliverTo.customerCode || ''
             }
           : null
       }

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

@@ -26,51 +26,81 @@ export async function activateBatchPicking(
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
     const worksheet = await worksheetController.activateBatchPicking(worksheetNo)
     const worksheetDetails = worksheet.worksheetDetails
     const companyDomain: Domain = worksheet?.bizplace.company.domain
 
-    let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-
-    // find for any existing marketplace store connections
-    const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-      where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
-      relations: ['marketplaceDistributors']
+    // Collect release good IDs from the controller result for post-commit processing
+    const orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+    const releaseGoodIds: string[] = orderInventories.reduce((data, orderInventory) => {
+      if (orderInventory?.releaseGood?.id && !data.includes(orderInventory.releaseGood.id)) {
+        data.push(orderInventory.releaseGood.id)
+      }
+      return data
+    }, [])
+
+    // Schedule all marketplace/LMD side effects to run AFTER the transaction commits.
+    // This prevents deadlocks caused by nested transactions competing for locks
+    // held by the outer @transaction decorator.
+    setImmediate(() => {
+      processPostActivationSideEffects(
+        domain,
+        user,
+        companyDomain,
+        worksheetNo,
+        worksheetDetails,
+        releaseGoodIds
+      ).catch(error => {
+        logger.error(`activate-batch-picking[postActivation]: ${worksheetNo}: ${error}`)
+      })
     })
 
-    const updateMarketplaceProductVariationStock = async (
-      worksheetDetails,
-      domain,
-      user,
-      marketplaceStores,
-      companyDomain
-    ) => {
+    return worksheet
+  } catch (error) {
+    logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
+    throw new Error('Something went wrong. Please contact support.')
+  }
+}
+
+/**
+ * Handles marketplace stock sync, MMS order packages, and LMD parcel creation.
+ * Runs outside the main activation transaction to prevent deadlocks.
+ */
+async function processPostActivationSideEffects(
+  domain: Domain,
+  user: User,
+  companyDomain: Domain,
+  worksheetNo: string,
+  worksheetDetails: any[],
+  releaseGoodIds: string[]
+) {
+  try {
+    // Find marketplace store connections
+    const marketplaceStores: MarketplaceStore[] = await getConnection()
+      .getRepository(MarketplaceStore)
+      .find({
+        where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+        relations: ['marketplaceDistributors']
+      })
+
+    // Update marketplace product variation stock
+    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
       try {
         await getConnection().transaction(async (tx2: EntityManager) => {
-          let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+          const orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
           const ecommerceCtrl: EcommerceController = new EcommerceController(tx2, domain, user)
           await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
         })
       } catch (error) {
-        logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
+        logger.error(`activate-batch-picking[marketplaceStockUpdate]: ${worksheetNo}: ${error}`)
       }
     }
 
-    if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-      updateMarketplaceProductVariationStock(worksheetDetails, domain, user, marketplaceStores, companyDomain)
-    }
+    if (!releaseGoodIds.length) return
 
-    try {
-      let releaseGoods: ReleaseGood[] = []
-      let releaseGoodIds: ReleaseGood[] = orderInventories.reduce((data, orderInventory) => {
-        if (!data.find(x => x.id == orderInventory.releaseGood.id)) {
-          data.push(orderInventory.releaseGood.id)
-        }
-        return data
-      }, [])
-
-      releaseGoods = await tx.getRepository(ReleaseGood).find({
+    // Load release goods and process marketplace order packages
+    await getConnection().transaction(async (tx: EntityManager) => {
+      const releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
         where: { id: In(releaseGoodIds) },
         relations: [
           'domain',
@@ -88,48 +118,43 @@ export async function activateBatchPicking(
         ]
       })
 
-      if (releaseGoods?.length) {
-        for (const releaseGood of releaseGoods) {
-          const orderSource = releaseGood?.source
-          const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: releaseGood.refNo, domain: companyDomain },
-            relations: ['marketplaceStore']
-          })
-
-          switch (orderSource) {
-            case ApplicationType.MMS:
-              if (marketplaceStores?.length) {
-                if (marketplaceOrder) {
-                  const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
-                  await ecommerceCtrl.createOrderPackage(
-                    tx,
-                    marketplaceOrder,
-                    companyDomain,
-                    marketplaceStore,
-                    releaseGood
-                  )
-                }
-              }
-              break
-            default:
-              break
+      if (!releaseGoods?.length) return
+
+      // Batch load marketplace orders for MMS release goods (avoids N+1 queries)
+      const mmsReleaseGoods = releaseGoods.filter(rg => rg?.source === ApplicationType.MMS)
+
+      if (mmsReleaseGoods.length && marketplaceStores?.length) {
+        const refNos = mmsReleaseGoods.map(rg => rg.refNo).filter(Boolean)
+        const marketplaceOrders: MarketplaceOrder[] = refNos.length
+          ? await tx.getRepository(MarketplaceOrder).find({
+              where: { orderNo: In(refNos), domain: companyDomain },
+              relations: ['marketplaceStore']
+            })
+          : []
+
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        for (const releaseGood of mmsReleaseGoods) {
+          try {
+            const marketplaceOrder = marketplaceOrders.find(mo => mo.orderNo === releaseGood.refNo)
+            if (marketplaceOrder) {
+              const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+              await ecommerceCtrl.createOrderPackage(tx, marketplaceOrder, companyDomain, marketplaceStore, releaseGood)
+            }
+          } catch (error) {
+            logger.error(`activate-batch-picking[mmsOrderPackage]: ${worksheetNo}: ${error}`)
           }
         }
-        // Process LMD orders
-        processLmdOrders(releaseGoods, domain, companyDomain, user)
       }
-    } catch (e) {
-      logger.error(e)
-    }
 
-    return worksheet
+      // Process LMD orders
+      processLmdOrders(releaseGoods, domain, companyDomain, user)
+    })
   } catch (error) {
-    logger.error(`activate-batch-picking[activateBatchPicking]: ${worksheetNo + ':' + error}`)
-    throw new Error('Something went wrong. Please contact support.')
+    logger.error(`activate-batch-picking[postActivation]: ${worksheetNo}: ${error}`)
   }
 }
 
-//triger create parcel for lmd orders
+// Trigger create parcel for LMD orders
 async function processLmdOrders(releaseGoods: ReleaseGood[], domain: Domain, companyDomain: Domain, user: User) {
   // Filter only those that need processing
   const validReleaseGoods = releaseGoods.filter(

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

@@ -7,12 +7,13 @@ import {
   Replenishment,
   ShippingOrder
 } from '@things-factory/sales-base'
+import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, InventoryChange, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
-import { fetchExecutingWorksheet } from '../../../utils'
+import { computeConversionString, fetchExecutingWorksheet } from '../../../utils'
 
 export const pickingWorksheetResolver = {
   async pickingWorksheet(_: any, { orderNo, locationSortingRules }, context: any) {
@@ -86,6 +87,8 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
       .leftJoinAndSelect('T_INV.inventory', 'INV')
       .leftJoinAndSelect('T_INV.product', 'PROD')
       .leftJoinAndSelect('T_INV.productDetail', 'PROD_DET')
+      .leftJoinAndSelect('PROD_DET.childProductDetail', 'CHILD_PROD_DET')
+      .leftJoinAndSelect('PROD_DET.parentProductDetails', 'PARENT_PROD_DETS')
       .leftJoinAndSelect('INV.location', 'LOC')
 
     if (locationSortingRules?.length > 0) {
@@ -106,6 +109,50 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
       .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
       .getMany()
 
+    const inventoryIds = worksheetDetails
+      .map((wd: WorksheetDetail) => wd.targetInventory?.inventory?.id)
+      .filter((id): id is string => id != null)
+    const inventoryIdsWithMissing = new Set<string>()
+    if (inventoryIds.length > 0) {
+      const rows = await tx
+        .getRepository(InventoryChange)
+        .createQueryBuilder('ic')
+        .select('DISTINCT ic.inventory_id', 'inventoryId')
+        .where('ic.inventory_id IN (:...ids)', { ids: inventoryIds })
+        .andWhere('ic.status = :status', { status: 'PENDING' })
+        .andWhere('ic.transaction_type = :transactionType', { transactionType: 'MISSING' })
+        .getRawMany()
+      rows.forEach((r: { inventoryId: string }) => inventoryIdsWithMissing.add(r.inventoryId))
+    }
+
+    const worksheetDetailInfos = worksheetDetails.map((pickingWSD: WorksheetDetail) => {
+      const targetInventory: OrderInventory = pickingWSD.targetInventory
+      const inventory: Inventory = targetInventory.inventory
+      const productDetail: ProductDetail = targetInventory.productDetail as ProductDetail
+      return {
+        name: pickingWSD.name,
+        palletId: inventory?.palletId,
+        cartonId: inventory?.cartonId,
+        batchId: inventory?.batchId,
+        batchIdRef: inventory?.batchIdRef,
+        product: inventory?.product,
+        qty: inventory?.qty,
+        binLocation: targetInventory?.binLocation || '',
+        releaseQty: targetInventory.releaseQty,
+        pickedQty: targetInventory.pickedQty,
+        status: pickingWSD.status,
+        description: pickingWSD.description,
+        targetName: targetInventory.name,
+        packingType: inventory?.packingType,
+        packingSize: inventory?.packingSize,
+        expirationDate: inventory?.expirationDate,
+        location: inventory?.location,
+        relatedOrderInv: targetInventory,
+        hasMissingInventoryChanges: inventory?.id ? inventoryIdsWithMissing.has(inventory.id) : false,
+        conversion: computeConversionString(targetInventory.releaseQty, productDetail)
+      }
+    })
+
     return {
       worksheetInfo: {
         worksheet,
@@ -123,40 +170,7 @@ export async function pickingWorksheet(domain: Domain, orderNo: String, location
         customerCompanyDomainId: releaseGood.bizplace?.company?.domain?.id,
         releaseGood
       },
-      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = pickingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-
-        const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
-          where: {
-            inventory: inventory.id,
-            status: 'PENDING',
-            transactionType: 'MISSING'
-          }
-        })
-
-        return {
-          name: pickingWSD.name,
-          palletId: inventory?.palletId,
-          cartonId: inventory?.cartonId,
-          batchId: inventory?.batchId,
-          batchIdRef: inventory?.batchIdRef,
-          product: inventory?.product,
-          qty: inventory?.qty,
-          binLocation: targetInventory?.binLocation || '',
-          releaseQty: targetInventory.releaseQty,
-          pickedQty: targetInventory.pickedQty,
-          status: pickingWSD.status,
-          description: pickingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory?.packingType,
-          packingSize: inventory?.packingSize,
-          expirationDate: inventory?.expirationDate,
-          location: inventory?.location,
-          relatedOrderInv: targetInventory,
-          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false
-        }
-      })
+      worksheetDetailInfos
     }
   }
 }
@@ -183,6 +197,8 @@ async function replenishmentWorksheet(orderNo: String, tx, domain, locationSorti
       .leftJoinAndSelect('T_INV.inventory', 'INV')
       .leftJoinAndSelect('T_INV.product', 'PROD')
       .leftJoinAndSelect('T_INV.productDetail', 'PROD_DET')
+      .leftJoinAndSelect('PROD_DET.childProductDetail', 'CHILD_PROD_DET')
+      .leftJoinAndSelect('PROD_DET.parentProductDetails', 'PARENT_PROD_DETS')
       .leftJoinAndSelect('INV.location', 'LOC')
 
     if (locationSortingRules?.length > 0) {
@@ -210,6 +226,7 @@ async function replenishmentWorksheet(orderNo: String, tx, domain, locationSorti
       worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
         const targetInventory: OrderInventory = pickingWSD.targetInventory
         const inventory: Inventory = targetInventory.inventory
+        const productDetail: ProductDetail = targetInventory.productDetail as ProductDetail
 
         return {
           name: pickingWSD.name,
@@ -229,7 +246,8 @@ async function replenishmentWorksheet(orderNo: String, tx, domain, locationSorti
           packingSize: inventory?.packingSize,
           expirationDate: inventory?.expirationDate,
           location: inventory?.location,
-          relatedOrderInv: targetInventory
+          relatedOrderInv: targetInventory,
+          conversion: computeConversionString(targetInventory.releaseQty, productDetail)
         }
       })
     }

package/server/graphql/resolvers/worksheet/sorting-worksheet.ts

@@ -3,7 +3,7 @@ import {
   SelectQueryBuilder
 } from 'typeorm'
 
-import { ProductBarcode } from '@things-factory/product-base'
+import { ProductBarcode, ProductDetail } from '@things-factory/product-base'
 import {
   ORDER_INVENTORY_STATUS,
   ORDER_STATUS,
@@ -13,7 +13,7 @@ import {
 import { Domain } from '@things-factory/shell'
 
 import { WORKSHEET_TYPE } from '../../../constants'
-import { fetchExecutingBatchWorksheet } from '../../../utils'
+import { computeConversionString, fetchExecutingBatchWorksheet } from '../../../utils'
 
 export const sortingWorksheetResolver = {
   async sortingWorksheet(_: any, { releaseGoodNo, taskNo }, context: any) {
@@ -66,6 +66,19 @@ export const sortingWorksheetResolver = {
       .orderBy('PROD.sku', 'ASC')
 
     const items: any[] = await qb.getRawMany()
+
+    // Collect unique productDetail IDs to fetch with relationships
+    const productDetailIds = [...new Set(items.map(item => item.productDetailId).filter(Boolean))]
+    const productDetailsMap = new Map<string, ProductDetail>()
+
+    if (productDetailIds.length > 0) {
+      const productDetails: ProductDetail[] = await getRepository(ProductDetail).find({
+        where: productDetailIds.map(id => ({ id })),
+        relations: ['childProductDetail', 'parentProductDetails']
+      })
+      productDetails.forEach(pd => productDetailsMap.set(pd.id, pd))
+    }
+
     let results = {
       worksheetInfo: {
         bizplaceName: releaseGood.bizplace.name,
@@ -79,6 +92,8 @@ export const sortingWorksheetResolver = {
       },
       worksheetDetailInfos: await Promise.all(
         items.map(async (item: any) => {
+          const productDetail = productDetailsMap.get(item.productDetailId)
+
           return {
             batchId: item?.batchId,
             productId: item?.productId,
@@ -96,6 +111,7 @@ export const sortingWorksheetResolver = {
             packingType: item?.packingType,
             packingSize: item?.packingSize,
             binRemarks: item?.binRemarks,
+            conversion: computeConversionString(item.releaseQty, productDetail),
             releaseGood
           }
         })

package/server/graphql/resolvers/worksheet/worksheets.ts

@@ -118,6 +118,7 @@ export const worksheetsResolver = {
       const releaseGoodPriorityDeliveryParam = params.filters.find(
         param => param.name === 'releaseGoodPriorityDelivery'
       )
+      const releaseGoodRtmParam = params.filters.find(param => param.name === 'releaseGoodRtm')
 
       if (
         releaseGoodParam ||
@@ -125,7 +126,8 @@ export const worksheetsResolver = {
         releaseGoodCrossDockingParam ||
         releaseGoodCourierOptionParam ||
         releaseGoodPackingOptionParam ||
-        releaseGoodPriorityDeliveryParam
+        releaseGoodPriorityDeliveryParam ||
+        releaseGoodRtmParam
       ) {
         // let arrFilters = []
         if (releaseGoodParam) {
@@ -176,6 +178,13 @@ export const worksheetsResolver = {
           )
         }
 
+        if (releaseGoodRtmParam) {
+          params.filters.splice(
+            params.filters.findIndex(item => item.name == 'releaseGoodRtm'),
+            1
+          )
+        }
+
         // const foundReleaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
         //   ...convertListParams({ filters: arrFilters }, domain.id)
         // })
@@ -555,6 +564,9 @@ export const worksheetsResolver = {
           priorityDelivery: releaseGoodPriorityDeliveryParam.value
         })
       }
+      if (releaseGoodRtmParam) {
+        qb.andWhere(`releaseGood.rtm = :rtm`, { rtm: releaseGoodRtmParam.value })
+      }
 
       ////Add sorting conditions
       const arrChildSortData = ['bizplace', 'arrivalNotice', 'releaseGood', 'returnOrder', 'inventoryCheck']

package/server/graphql/types/worksheet/contact-point-info.ts

@@ -9,5 +9,6 @@ export const ContactPointInfo = gql`
     phone: String
     contactName: String
     businessRestDay: String
+    customerCode: String
   }
 `

package/server/graphql/types/worksheet/worksheet-detail-info.ts

@@ -75,6 +75,7 @@ export const WorksheetDetailInfo = gql`
     toteName: String
     completed: Boolean
     packingTypeSize: String
+    conversion: String
     reusablePalletName: String
     expirationPeriod: Int
     productDetail: ProductDetail

package/server/graphql/types/worksheet/worksheet-info.ts

@@ -34,6 +34,7 @@ export const WorksheetInfo = gql`
     refNo: String
     refNo2: String
     refNo3: String
+    rtm: String
     looseItem: String
     orderVas: [WorksheetDetail]
     orderPackage: OrderPackage

package/server/utils/worksheet-util.ts

@@ -20,6 +20,13 @@ import { Domain } from '@things-factory/shell'
 import { WORKSHEET_STATUS } from '../constants'
 import { Worksheet } from '../entities'
 
+export interface PackingConversionDetail {
+  packingType?: string
+  packingSize?: number
+  childProductDetail?: PackingConversionDetail | null
+  parentProductDetails?: PackingConversionDetail[] | null
+}
+
 export async function fetchExecutingWorksheet(
   domain: Domain,
   bizplace: Bizplace,
@@ -101,3 +108,47 @@ export async function fetchExecutingBatchWorksheet(
     throw new Error(`Current worksheet status (${worksheet.status}) is not proper to execute it.`)
   }
 }
+
+export function computeConversionString(releaseQty: number, productDetail: PackingConversionDetail | null): string {
+  if (!productDetail || !releaseQty || releaseQty <= 0) {
+    return ''
+  }
+
+  const currentPackingType = productDetail.packingType
+  const childProductDetail = productDetail.childProductDetail
+  const parentProductDetails = productDetail.parentProductDetails
+
+  // Priority 1: If has child → convert to child terms (downward)
+  if (childProductDetail) {
+    const packingSize = productDetail.packingSize || 1
+    const childPackingType = childProductDetail.packingType
+
+    if (packingSize > 1) {
+      const totalChildUnits = releaseQty * packingSize
+      return `${totalChildUnits} ${childPackingType}`
+    }
+  }
+
+  // Priority 2: If has parent (no child) → convert to parent terms (upward)
+  // If multiple parents, select the one with lowest packingSize
+  if (parentProductDetails && parentProductDetails.length > 0) {
+    const parent = parentProductDetails.reduce((min, p) => ((p.packingSize || 1) < (min.packingSize || 1) ? p : min))
+    const parentPackingSize = parent.packingSize || 1
+    const parentPackingType = parent.packingType
+
+    if (parentPackingSize > 1) {
+      const fullParents = Math.floor(releaseQty / parentPackingSize)
+      const remainder = releaseQty % parentPackingSize
+
+      if (fullParents > 0 && remainder > 0) {
+        return `${fullParents} ${parentPackingType}, ${remainder} ${currentPackingType}`
+      } else if (fullParents > 0) {
+        return `${fullParents} ${parentPackingType}`
+      } else if (remainder > 0) {
+        return `${remainder} ${currentPackingType}`
+      }
+    }
+  }
+
+  return ''
+}