@things-factory/worksheet-base 4.3.753 → 4.3.756

package/server/graphql/resolvers/worksheet/find-sorting-release-orders-by-task-no.ts

@@ -8,153 +8,330 @@ import {
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
-import { Location } from '@things-factory/warehouse-base'
 import { SortingWorksheetController } from '../../../controllers/'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
 
+// Simple in-memory cache for settings with TTL
+const settingsCache = new Map<string, { value: Setting | null; expiry: number }>()
+const SETTINGS_CACHE_TTL = 5 * 60 * 1000 // 5 minutes
+
+/**
+ * Get setting with caching to avoid repeated database queries
+ */
+async function getCachedSetting(
+  tx: EntityManager,
+  domain: Domain,
+  category: string,
+  name: string
+): Promise<Setting | null> {
+  const cacheKey = `${domain.id}:${category}:${name}`
+  const cached = settingsCache.get(cacheKey)
+
+  if (cached && cached.expiry > Date.now()) {
+    return cached.value
+  }
+
+  const setting = await tx.getRepository(Setting).findOne({
+    where: { domain, category, name }
+  })
+
+  settingsCache.set(cacheKey, { value: setting || null, expiry: Date.now() + SETTINGS_CACHE_TTL })
+  return setting || null
+}
+
+/**
+ * Find worksheet by release good name - returns task info if found
+ */
+async function findWorksheetByReleaseGoodName(
+  tx: EntityManager,
+  domain: Domain,
+  taskNo: string
+): Promise<{ taskNo: string; selectedReleaseGood: string; status: string } | null> {
+  const result = await tx
+    .getRepository(WorksheetEntity)
+    .createQueryBuilder('ws')
+    .select('ws.task_no', 'taskNo')
+    .addSelect('ws.status', 'wsStatus')
+    .addSelect('rg.name', 'releaseGoodName')
+    .addSelect('rg.status', 'releaseGoodStatus')
+    .innerJoin('worksheet_details', 'wd', `ws.id = wd.worksheet_id`)
+    .innerJoin('order_inventories', 'oi', `wd.target_inventory_id = oi.id AND wd."type" = 'SORTING'`)
+    .innerJoin('release_goods', 'rg', `rg.id = oi.release_good_id`)
+    .where('rg.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('rg.name = :name', { name: taskNo })
+    .andWhere('rg.status IN (:...statuses)', {
+      statuses: [ORDER_STATUS.READY_TO_SORT, ORDER_STATUS.SORTING, ORDER_STATUS.LOADING, ORDER_STATUS.DONE]
+    })
+    .andWhere('ws.type = :type', { type: WORKSHEET_TYPE.SORTING })
+    .getRawOne()
+
+  if (!result) return null
+
+  if (result.releaseGoodStatus === 'LOADING' || result.releaseGoodStatus === 'DONE') {
+    throw new Error(`Release Good already sorted`)
+  }
+
+  return {
+    taskNo: result.taskNo,
+    selectedReleaseGood: result.releaseGoodName,
+    status: result.wsStatus
+  }
+}
+
+/**
+ * Find worksheet by taskNo directly - optimized to only load needed relations
+ */
+async function findWorksheetByTaskNo(
+  tx: EntityManager,
+  domain: Domain,
+  taskNo: string,
+  loadWorksheetDetails: boolean = false
+): Promise<WorksheetEntity | null> {
+  const relations = loadWorksheetDetails ? ['bizplace', 'bizplace.domain', 'worksheetDetails'] : ['bizplace', 'bizplace.domain']
+
+  return tx.getRepository(WorksheetEntity).findOne({
+    where: { taskNo, type: WORKSHEET_TYPE.SORTING, domain },
+    relations
+  })
+}
+
+/**
+ * Find worksheet by bin location - combines location lookup and worksheet query
+ * Returns both taskNo and worksheet status in a single optimized query
+ */
+async function findWorksheetByBinLocation(
+  tx: EntityManager,
+  domain: Domain,
+  binName: string
+): Promise<{ taskNo: string; worksheetId: string; status: string } | null> {
+  // Combined query: location -> order inventory -> worksheet in one go
+  const result = await tx
+    .getRepository(OrderInventoryEntity)
+    .createQueryBuilder('oi')
+    .select('ws2.task_no', 'taskNo')
+    .addSelect('ws2.id', 'worksheetId')
+    .addSelect('ws2.status', 'status')
+    .innerJoin('locations', 'loc', 'oi.bin_location_id = loc.id')
+    .innerJoin('worksheets', 'ws', `oi.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
+    .innerJoin('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
+    .innerJoin('release_goods', 'rg', 'rg.id = oi.release_good_id')
+    .where('oi.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('loc.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('loc.name = :binName', { binName })
+    .andWhere('oi.status IN (:...orderInventoryStatus)', {
+      orderInventoryStatus: [ORDER_INVENTORY_STATUS.READY_TO_SORT, ORDER_INVENTORY_STATUS.SORTING]
+    })
+    .andWhere('rg.status IN (:...statuses)', {
+      statuses: [ORDER_STATUS.READY_TO_SORT, ORDER_STATUS.SORTING]
+    })
+    .andWhere('ws2.status IN (:...worksheetStatuses)', {
+      worksheetStatuses: [WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]
+    })
+    .getRawOne()
+
+  if (!result) {
+    throw new Error(`Bin do not have any batch picking order.`)
+  }
+
+  return {
+    taskNo: result.taskNo,
+    worksheetId: result.worksheetId,
+    status: result.status
+  }
+}
+
+/**
+ * Handle worksheet activation if needed
+ */
+async function handleWorksheetActivation(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  task: WorksheetEntity
+): Promise<void> {
+  if (task.status !== 'DEACTIVATED') return
+
+  const sortingWSCtrl = new SortingWorksheetController(tx, domain, user)
+
+  // Use cached settings
+  const directActivateSetting = await getCachedSetting(
+    tx,
+    domain,
+    'id-rule',
+    'enable-direct-activate-sorting-worksheet'
+  )
+
+  if (!directActivateSetting || directActivateSetting.value?.toLowerCase() !== 'true') {
+    throw new Error('Kindly go to sorting worksheet page to activate the sorting worksheet')
+  }
+
+  // Only fetch partner setting if main setting is enabled
+  const partnerSetting: PartnerSetting | null = await tx.getRepository(PartnerSetting).findOne({
+    where: {
+      setting: directActivateSetting,
+      domain: domain,
+      partnerDomain: task.bizplace?.domain
+    }
+  })
+
+  // If partner setting exists and is false, don't activate
+  if (partnerSetting && (partnerSetting.value as string)?.toLowerCase() !== 'true') {
+    throw new Error('Kindly go to sorting worksheet page to activate the sorting worksheet')
+  }
+
+  // Load worksheet details only when needed for activation
+  if (!task.worksheetDetails) {
+    const taskWithDetails = await tx.getRepository(WorksheetEntity).findOne({
+      where: { id: task.id },
+      relations: ['worksheetDetails']
+    })
+    task.worksheetDetails = taskWithDetails?.worksheetDetails || []
+  }
+
+  await sortingWSCtrl.activateSorting(task.name, task.worksheetDetails)
+}
+
+/**
+ * Build and execute release goods query with item counts in a SINGLE query
+ * Optimizations:
+ * - Removed redundant Domain join (filter directly on ws.domain_id)
+ * - Combined release goods + counts into one query using aggregate functions
+ */
+async function getReleaseGoodsWithCounts(
+  tx: EntityManager,
+  domain: Domain,
+  taskNo: string
+): Promise<ReleaseGoodEntity[]> {
+  // Single query that gets release goods with their counts using aggregation
+  const releaseGoods: any[] = await tx
+    .getRepository(WorksheetEntity)
+    .createQueryBuilder('ws')
+    .select('rg.id', 'id')
+    .addSelect('rg.name', 'name')
+    .addSelect('rg.refNo', 'refNo')
+    .addSelect('rg.refNo2', 'refNo2')
+    .addSelect('rg.status', 'status')
+    .addSelect('rg.district', 'district')
+    .addSelect('rg.attention_company', 'attentionCompany')
+    .addSelect('rg.delivery_address_1', 'deliveryAddress1')
+    .addSelect('rg.delivery_address_2', 'deliveryAddress2')
+    .addSelect('rg.delivery_address_3', 'deliveryAddress3')
+    .addSelect('rg.delivery_address_4', 'deliveryAddress4')
+    .addSelect('rg.delivery_address_5', 'deliveryAddress5')
+    .addSelect('rg.created_at', 'createdAt')
+    .addSelect('u.name', 'sortedByUser')
+    // Counts computed directly in the same query
+    .addSelect('COUNT(oi.id)', 'totalCount')
+    .addSelect('SUM(CASE WHEN oi.sorted_qty = oi.release_qty THEN 1 ELSE 0 END)', 'completedCount')
+    .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
+    .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
+    .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
+    .leftJoin(User, 'u', 'rg.sorted_by_id = u.id')
+    // Filter directly on ws.domain_id - no need to join Domain table
+    .where('ws.domain_id = :domainId', { domainId: domain.id })
+    .andWhere('ws.taskNo = :taskNo', { taskNo })
+    .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
+    .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
+    .groupBy('rg.id')
+    .addGroupBy('rg.name')
+    .addGroupBy('rg.refNo')
+    .addGroupBy('rg.refNo2')
+    .addGroupBy('rg.status')
+    .addGroupBy('rg.district')
+    .addGroupBy('rg.attention_company')
+    .addGroupBy('rg.delivery_address_1')
+    .addGroupBy('rg.delivery_address_2')
+    .addGroupBy('rg.delivery_address_3')
+    .addGroupBy('rg.delivery_address_4')
+    .addGroupBy('rg.delivery_address_5')
+    .addGroupBy('rg.created_at')
+    .addGroupBy('u.name')
+    .orderBy('rg.created_at', 'ASC')
+    .getRawMany()
+
+  // Transform results to include itemCounts
+  return releaseGoods.map(rg => {
+    const total = parseInt(rg.totalCount) || 0
+    const completed = parseInt(rg.completedCount) || 0
+    return {
+      id: rg.id,
+      name: rg.name,
+      refNo: rg.refNo,
+      refNo2: rg.refNo2,
+      status: rg.status,
+      district: rg.district,
+      attentionCompany: rg.attentionCompany,
+      deliveryAddress1: rg.deliveryAddress1,
+      deliveryAddress2: rg.deliveryAddress2,
+      deliveryAddress3: rg.deliveryAddress3,
+      deliveryAddress4: rg.deliveryAddress4,
+      deliveryAddress5: rg.deliveryAddress5,
+      sortedByUser: rg.sortedByUser,
+      itemCounts: {
+        total,
+        pending: total - completed
+      }
+    }
+  }) as ReleaseGoodEntity[]
+}
+
 export const findSortingReleaseOrdersByTaskNoResolver = {
   async findSortingReleaseOrdersByTaskNo(_: any, { taskNo }, context: any) {
+    const startTime = Date.now()
     const { domain, tx, user }: { domain: Domain; tx: EntityManager; user: User } = context.state
 
-    let selectedReleaseGood = null
-    let ws = await tx.getRepository(WorksheetEntity).createQueryBuilder('ws')
-      .addSelect('rg.name', 'release_good_name')
-      .addSelect('rg.status', 'release_good_status')
-      .innerJoin('worksheet_details', 'wd', `ws.id = wd.worksheet_id`)
-      .innerJoin('order_inventories', 'oi', `wd.target_inventory_id = oi.id and wd."type" ='SORTING'`)
-      .innerJoin('release_goods', 'rg', `rg.id = oi.release_good_id`)
-      .where('rg.domain_id = :domainId', { domainId: domain.id })
-      .andWhere('rg.name = :name', { name: taskNo })
-      .andWhere('rg.status IN (:...statuses)', {
-        statuses: [ORDER_STATUS.READY_TO_SORT, ORDER_STATUS.SORTING, ORDER_STATUS.LOADING, ORDER_STATUS.DONE]
-      })
-      .andWhere('ws.type = :type', { type: WORKSHEET_TYPE.SORTING })
-      .getRawOne()
-
-    if (ws) {
-      if (ws.release_good_status == 'LOADING' || ws.release_good_status == 'DONE') {
-        throw new Error(`Release Good already sorted`);
-      }
+    let selectedReleaseGood: string | null = null
+    let task: WorksheetEntity | null = null
+    let resolvedTaskNo = taskNo
+
+    // Step 1: Try to find by release good name first (most common case)
+    const releaseGoodResult = await findWorksheetByReleaseGoodName(tx, domain, taskNo)
+
+    if (releaseGoodResult) {
+      selectedReleaseGood = releaseGoodResult.selectedReleaseGood
+      resolvedTaskNo = releaseGoodResult.taskNo
 
-      selectedReleaseGood = ws.release_good_name
-      taskNo = ws.ws_task_no
+      // Only load worksheetDetails if we need them for activation
+      const needsActivation = releaseGoodResult.status === 'DEACTIVATED'
+      task = await findWorksheetByTaskNo(tx, domain, resolvedTaskNo, needsActivation)
     }
 
-    let task = await tx.getRepository(WorksheetEntity).findOne({
-      where: { taskNo, type: WORKSHEET_TYPE.SORTING, domain },
-      relations: ['bizplace', 'bizplace.domain', 'worksheetDetails']
-    })
+    // Step 2: Try to find by worksheet taskNo directly
+    if (!task) {
+      task = await findWorksheetByTaskNo(tx, domain, taskNo, false)
+    }
 
-    // Find Task based on Bin
+    // Step 3: Try to find by bin location
     if (!task) {
-      const binLocation: Location = await tx.getRepository(Location).findOne({
-        where: { domain, name: taskNo }
-      })
-
-      if (binLocation) {
-        const qb: SelectQueryBuilder<OrderInventoryEntity> = tx
-          .getRepository(OrderInventoryEntity)
-          .createQueryBuilder('orderInventory')
-
-        qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-          .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
-          .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
-          .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
-          .innerJoinAndSelect('bizplace.domain', 'domain')
-          .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-          .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
-            orderInventoryStatus: [ORDER_INVENTORY_STATUS.READY_TO_SORT, ORDER_INVENTORY_STATUS.SORTING]
-          })
-          .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-          .andWhere('releaseGood.status IN (:...statuses)', {
-            statuses: [ORDER_STATUS.READY_TO_SORT, ORDER_STATUS.SORTING]
-          })
-
-        const orderInventoryByBin = await qb.getRawOne()
-        if (orderInventoryByBin?.releaseGood_id) {
-          taskNo = orderInventoryByBin.ws_task_no
-          task = await tx.getRepository(WorksheetEntity).findOne({
-            where: {
-              taskNo,
-              status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]),
-              type: WORKSHEET_TYPE.SORTING,
-              domain
-            },
-            relations: ['worksheetDetails']
-          })
-        } else {
-          throw new Error(`Bin do not have any batch picking order.`)
-        }
+      const binResult = await findWorksheetByBinLocation(tx, domain, taskNo)
+
+      if (binResult) {
+        resolvedTaskNo = binResult.taskNo
+        // Only load worksheetDetails if we need them for activation
+        const needsActivation = binResult.status === 'DEACTIVATED'
+        task = await findWorksheetByTaskNo(tx, domain, resolvedTaskNo, needsActivation)
       }
     }
 
-    if (!task) throw new Error('Unable to find task no.')
-
-    if (task.status === 'DEACTIVATED') {
-      const sortingWSCtrl: SortingWorksheetController = new SortingWorksheetController(tx, domain, user)
-
-      const directActivateSortingWorksheet: Setting = await tx.getRepository(Setting).findOne({
-        where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-sorting-worksheet' }
-      })
-
-      const partnerDirectActivateSortingWorksheetSetting: PartnerSetting = await tx
-        .getRepository(PartnerSetting)
-        .findOne({
-          where: {
-            setting: directActivateSortingWorksheet,
-            domain: domain,
-            partnerDomain: task.bizplace?.domain
-          }
-        })
-
-      if (directActivateSortingWorksheet != undefined && directActivateSortingWorksheet.value.toLowerCase() == 'true') {
-        if (partnerDirectActivateSortingWorksheetSetting != undefined) {
-          if (partnerDirectActivateSortingWorksheetSetting.value.toLowerCase() == 'true')
-            await sortingWSCtrl.activateSorting(task.name, task.worksheetDetails)
-        } else {
-          await sortingWSCtrl.activateSorting(task.name, task.worksheetDetails)
-        }
-      } else {
-        throw new Error('Kindly go to sorting worksheet page to activate the sorting worksheet')
-      }
+    if (!task) {
+      throw new Error('Unable to find task no.')
+    }
+
+    // Step 4: Handle activation if needed
+    await handleWorksheetActivation(tx, domain, user, task)
+
+    // Step 5: Get release goods with counts
+    const releaseGoods = await getReleaseGoodsWithCounts(tx, domain, resolvedTaskNo)
+
+    // Performance logging (only in development/debug mode)
+    const elapsed = Date.now() - startTime
+    if (elapsed > 1000) {
+      console.warn(`[PERF] findSortingReleaseOrdersByTaskNo took ${elapsed}ms for taskNo: ${taskNo}`)
     }
 
-    const qb: SelectQueryBuilder<WorksheetEntity> = tx
-      .getRepository(WorksheetEntity)
-      .createQueryBuilder('ws')
-      .select('rg.id as id')
-      .addSelect('rg.name as name')
-      .addSelect('rg.refNo as "refNo"')
-      .addSelect('rg.refNo2 as "refNo2"')
-      .addSelect('rg.status as status')
-      .addSelect('rg.district as "district"')
-      .addSelect('rg.attention_company as "attentionCompany"')
-      .addSelect('rg.delivery_address_1 as "deliveryAddress1"')
-      .addSelect('rg.delivery_address_2 as "deliveryAddress2"')
-      .addSelect('rg.delivery_address_3 as "deliveryAddress3"')
-      .addSelect('rg.delivery_address_4 as "deliveryAddress4"')
-      .addSelect('rg.delivery_address_5 as "deliveryAddress5"')
-      .addSelect('user.name as "sortedByUser"')
-      .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
-      .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
-      .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
-      .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
-      .leftJoin(User, 'user', 'rg.sorted_by_id = user.id')
-      .where('domain.id = :domainId', { domainId: domain.id })
-      .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
-      .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
-      .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
-      .groupBy('rg.id')
-      .addGroupBy('rg.name')
-      .addGroupBy('rg.status')
-      .addGroupBy('user.name')
-      .orderBy('rg.createdAt', 'ASC')
-
-    const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-
-    return { releaseGoods, taskNo, selectedReleaseGood }
+    return { releaseGoods, taskNo: resolvedTaskNo, selectedReleaseGood }
   }
 }

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

@@ -24,7 +24,7 @@ import { havingVasResolver } from './having-vas'
 import { Mutations as InspectMutations } from './inspecting'
 import { inventoriesByPalletResolver } from './inventories-by-pallet'
 import { loadedInventories } from './loaded-inventories'
-import { Mutations as LoadingMutations } from './loading'
+import { Mutations as LoadingMutations, Query as LoadingQuery } from './loading'
 import { loadingWorksheetResolver } from './loading-worksheet'
 import { notTallyTargetInventoriesResolver } from './not-tally-target-inventories'
 import { Mutations as PackingMutations } from './packing'
@@ -115,7 +115,8 @@ export const Query = {
   ...findSortingReleaseOrdersByTaskNoResolver,
   ...findReleaseOrdersByTaskNoResolver,
   ...fetchDeliveryOrderROResolver,
-  ...putawayReplenishmentWorksheetResolver
+  ...putawayReplenishmentWorksheetResolver,
+  ...LoadingQuery
 }
 
 export const Mutation = {

package/server/graphql/resolvers/worksheet/loading/index.ts

@@ -2,6 +2,7 @@ import { activateLoadingResolver } from './activate-loading'
 import { loadingResolver } from './loading'
 import { undoLoadingResolver } from './undo-loading'
 import { completeLoadingResolver } from './complete-loading'
+import { validateQcSealsResolver } from './validate-qc-seals'
 
 export const Mutations = {
   ...activateLoadingResolver,
@@ -9,3 +10,7 @@ export const Mutations = {
   ...undoLoadingResolver,
   ...completeLoadingResolver
 }
+
+export const Query = {
+  ...validateQcSealsResolver
+}

package/server/graphql/resolvers/worksheet/loading/validate-qc-seals.ts

@@ -0,0 +1,91 @@
+import { EntityManager, IsNull } from 'typeorm'
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { OrderTote, OrderToteSeal, ReleaseGood } from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
+
+export const validateQcSealsResolver = {
+  async validateQcSeals(
+    _: any,
+    { releaseGoodNo },
+    context: any
+  ): Promise<{ valid: boolean; error?: string; minimumSealNumber?: number }> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    try {
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+        where: { domain, name: releaseGoodNo },
+        relations: ['bizplace', 'bizplace.domain']
+      })
+
+      if (!releaseGood) {
+        return { valid: false, error: 'Release good not found', minimumSealNumber: 0 }
+      }
+
+      // Check enable-tote-scanning setting
+      let enableToteScanningSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: {
+          domain: domain,
+          category: 'id-rule',
+          name: 'enable-tote-scanning'
+        }
+      })
+
+      // Check minimum-seal-number setting (needed for banner display)
+      let minimumSealNumberSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: {
+          domain: domain,
+          category: 'id-rule',
+          name: 'minimum-seal-number'
+        }
+      })
+
+      const minimumSealNumber = parseInt(minimumSealNumberSetting?.value || '0', 10)
+
+      if (enableToteScanningSetting) {
+        // enable-tote-scanning is numeric: 0 = disabled, >= 1 = enabled
+        const enableToteScanningValue = parseInt(enableToteScanningSetting.value || '0', 10)
+
+        if (enableToteScanningValue >= 1) {
+          // Check if there are unsealed totes (closedDate is null)
+          const foundNotSealedOrderTote = await tx
+            .getRepository(OrderTote)
+            .findOne({ where: { releaseGood, closedDate: IsNull() } })
+
+          if (foundNotSealedOrderTote) {
+            return {
+              valid: false,
+              error: `Please seal the tote(s) before proceeding. Minimum ${minimumSealNumber} seal(s) required.`,
+              minimumSealNumber
+            }
+          }
+
+          // If minimum-seal-number > 0, validate seal counts per tote
+          if (minimumSealNumber > 0) {
+            // Get all order totes for this release good
+            const orderTotes: OrderTote[] = await tx.getRepository(OrderTote).find({
+              where: { releaseGood },
+              relations: ['orderToteSeals']
+            })
+
+            // Validate each tote has at least minimum-seal-number seals
+            for (const orderTote of orderTotes) {
+              const sealCount = orderTote.orderToteSeals?.length || 0
+              if (sealCount < minimumSealNumber) {
+                return {
+                  valid: false,
+                  error: `Tote ${orderTote.name} has ${sealCount} seal(s), but minimum ${minimumSealNumber} seal(s) required`,
+                  minimumSealNumber
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return { valid: true, minimumSealNumber }
+    } catch (error) {
+      return { valid: false, error: error.message || 'Validation failed', minimumSealNumber: 0 }
+    }
+  }
+}

package/server/graphql/types/worksheet/index.ts

@@ -22,6 +22,7 @@ import { ProductApproval } from './product-approval'
 import { ReleaseGoodWorksheet } from './release-good-worksheet'
 import { ReturnOrderWorksheet } from './return-order-worksheet'
 import { SellercraftDocument } from './sellercraft-document'
+import { ValidateQcSealsResult } from './validate-qc-seals-result'
 import { VasOrderWorksheet } from './vas-order-worksheet'
 import { WebspertDocument } from './webspert-document'
 import { Worksheet } from './worksheet'
@@ -864,6 +865,8 @@ export const Query = /* GraphQL */ `
   findSortingReleaseOrdersByTaskNo(taskNo: String!): FindReleaseOrdersByTaskNo @privilege(category: "worksheet", privilege: "query") @transaction
 
   findReleaseOrdersByTaskNo(taskNo: String!): FindReleaseOrdersByTaskNo @privilege(category: "worksheet", privilege: "query") @transaction
+
+  validateQcSeals(releaseGoodNo: String!): ValidateQcSealsResult @privilege(category: "worksheet", privilege: "query") @transaction
 `
 
 export const Types = /* GraphQL */ [
@@ -898,5 +901,6 @@ export const Types = /* GraphQL */ [
   DeliveryOrderRO,
   GenerateBatchPickInfo,
   MultipleReleaseGoodWorksheet,
-  LocationFilter
+  LocationFilter,
+  ValidateQcSealsResult
 ]

package/server/graphql/types/worksheet/validate-qc-seals-result.ts

@@ -0,0 +1,9 @@
+import { gql } from 'apollo-server-koa'
+
+export const ValidateQcSealsResult = gql`
+  type ValidateQcSealsResult {
+    valid: Boolean!
+    error: String
+    minimumSealNumber: Int
+  }
+`

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

@@ -14,6 +14,7 @@ export const WorksheetInfo = gql`
     marketplaceStatus: String
     customerCompanyDomainId: String
     binLocationName: String
+    isReleaseGoodScan: Boolean
     bizplace: Bizplace
     containerNo: String
     airwayBill: String