@things-factory/operato-wms 4.3.752 → 4.3.755

package/server/entities/route-label-sequence-log.ts

@@ -0,0 +1,47 @@
+import { CreateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn } from 'typeorm'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity('route_label_sequence_logs')
+@Index('ix_route_label_sequence_logs_0', (l: RouteLabelSequenceLog) => [
+  l.domain,
+  l.releaseGoodId,
+  l.field,
+  l.createdAt
+])
+@Index('ix_route_label_sequence_logs_1', (l: RouteLabelSequenceLog) => [l.domain, l.field, l.createdAt])
+export class RouteLabelSequenceLog {
+  @PrimaryGeneratedColumn('uuid')
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  domain?: Domain
+
+  @RelationId((l: RouteLabelSequenceLog) => l.domain)
+  domainId?: string
+
+  @Column()
+  releaseGoodId: string
+
+  @Column()
+  field: string
+
+  @Column({ type: 'int' })
+  from: number
+
+  @Column({ type: 'int' })
+  to: number
+
+  @Column({ type: 'int' })
+  qty: number
+
+  @CreateDateColumn()
+  createdAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((l: RouteLabelSequenceLog) => l.creator)
+  creatorId?: string
+}

package/server/graphql/resolvers/index.ts

@@ -8,6 +8,7 @@ import * as Reports from './reports'
 import * as InventoryComparison from './inventory-comparison'
 import * as ShippingProviders from './shipping-provider'
 import * as WarehouseInventoryAdjustment from './warehouse-inventory-adjustment'
+import * as RouteLabel from './route-label'
 import * as ZoneWorksheet from './zone-worksheet'
 import * as Outbound from './outbound'
 
@@ -21,6 +22,7 @@ export const queries = [
   Other.Query,
   Reports.Query,
   ShippingProviders.Query,
+  RouteLabel.Query,
   ZoneWorksheet.Query,
   Outbound.Query
 ]
@@ -28,6 +30,7 @@ export const queries = [
 export const mutations = [
   Other.Mutation,
   WarehouseInventoryAdjustment.Mutation,
+  RouteLabel.Mutation,
   ZoneWorksheet.Mutation,
   Outbound.Mutation
 ]

package/server/graphql/resolvers/outbound/complete-load.ts

@@ -6,6 +6,7 @@ import {
   ReleaseGood,
   OrderInventory,
   OrderProduct,
+  OrderTote,
   PowrupController,
   OrderPackage,
   ORDER_STATUS,
@@ -17,6 +18,11 @@ import { Powrup } from '@things-factory/integration-powrup'
 import { Setting } from '@things-factory/setting-base'
 import { webhookHandler, WebhookEventsEnum } from '@things-factory/integration-base'
 
+function parseNonNegativeInt(value: any): number {
+  const n = parseInt(value ?? '0', 10)
+  return Number.isFinite(n) ? Math.max(0, n) : 0
+}
+
 export const completeLoad = {
   async completeLoad(_: any, { orderId, worksheetId }, context: any) {
     const { domain, tx, user }: { domain: Domain; tx: EntityManager; user: User } = context.state
@@ -119,6 +125,41 @@ async function completeLoading(
       releaseGood.ownTransport = ownTransportFlag
     }
 
+    // If minimum seal is 0 (or invalid/negative), auto-close any open totes for this order.
+    // This supports the "0 seal required" scenario without blocking tote usage during QC/loading.
+    try {
+      let sealNoSetting: Setting = await tx.getRepository(Setting).findOne({
+        where: {
+          domain: (releaseGood as any).bizplace?.domain,
+          name: 'minimum-seal-number'
+        }
+      })
+
+      if (!sealNoSetting) {
+        sealNoSetting = await tx.getRepository(Setting).findOne({
+          where: {
+            domain,
+            name: 'minimum-seal-number'
+          }
+        })
+      }
+
+      const minimumSealRequired = parseNonNegativeInt(sealNoSetting?.value)
+      if (minimumSealRequired <= 0) {
+        await tx
+          .getRepository(OrderTote)
+          .createQueryBuilder()
+          .update(OrderTote)
+          .set({ closedDate: currentTime, updater: user })
+          .where('release_good_id = :releaseGoodId', { releaseGoodId: releaseGood.id })
+          .andWhere('closed_date IS NULL')
+          .execute()
+      }
+    } catch (e) {
+      // do not fail completion if tote auto-close fails
+      console.error('Failed to auto-close order totes:', e)
+    }
+
     await updateOrderInventories(tx, orderInventories, ORDER_INVENTORY_STATUS.TERMINATED, user, currentTime)
     await updateWorksheet(tx, worksheet, WORKSHEET_STATUS.DONE, user, currentTime)
     webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.LoadingCompleted)
@@ -210,4 +251,4 @@ async function updateReleaseGood(tx, releaseGood, status, user, currentTime) {
   if (status === ORDER_STATUS.DONE) {
     webhookHandler(releaseGood, releaseGood.bizplace, WebhookEventsEnum.ReleaseOrderCompleted)
   }
-}
+}

package/server/graphql/resolvers/outbound/find-loadable-release-good-by-bin.ts

@@ -31,10 +31,17 @@ const buildfindReleaseGoodByNameQuery = (tx: EntityManager, domainId: string, or
 }
 
 /**
- * Builds a query to find order inventories by bin location
+ * Builds a query to find order inventories
+ * @param tx - Entity manager
+ * @param domainId - Domain ID
+ * @param options - Optional filters: locationId for bin location, releaseGoodId for release good
  */
-const buildOrderInventoryQuery = (tx: EntityManager, domainId: string, locationId: string) => {
-  return tx
+const buildOrderInventoryQuery = (
+  tx: EntityManager,
+  domainId: string,
+  options?: { locationId?: string; releaseGoodId?: string }
+) => {
+  const queryBuilder = tx
     .getRepository(OrderInventory)
     .createQueryBuilder('orderInventory')
     .leftJoinAndSelect('orderInventory.inventory', 'inventory')
@@ -50,19 +57,32 @@ const buildOrderInventoryQuery = (tx: EntityManager, domainId: string, locationI
         ORDER_INVENTORY_STATUS.LOADED
       ]
     })
-    .andWhere('orderInventory.bin_location_id = :locationId', { locationId })
-    .orderBy('orderInventory.createdAt', 'ASC')
+
+  if (options?.locationId) {
+    queryBuilder.andWhere('orderInventory.bin_location_id = :locationId', { locationId: options.locationId })
+  }
+
+  if (options?.releaseGoodId) {
+    queryBuilder.andWhere('orderInventory.release_good_id = :releaseGoodId', { releaseGoodId: options.releaseGoodId })
+  }
+
+  return queryBuilder.orderBy('orderInventory.createdAt', 'ASC')
 }
 
 /**
  * Transforms order inventory data into the required worksheet format
+ * @param orderInventories - Array of order inventories
+ * @param releaseGood - Optional release good (when scanning by order number)
  */
-const transformToWorksheetFormat = (orderInventories: OrderInventory[]) => {
+const transformToWorksheetFormat = (orderInventories: OrderInventory[], releaseGood?: ReleaseGood) => {
   if (!orderInventories.length) return null
 
   // Extract unique bin location names
   const uniqueBinLocations = [...new Set(orderInventories.map(oi => oi.binLocation?.name).filter(Boolean))]
 
+  // Get release good from first order inventory if not provided
+  const firstReleaseGood = releaseGood || orderInventories[0]?.releaseGood
+
   return {
     worksheetInfo: {
       worksheet: {
@@ -73,8 +93,22 @@ const transformToWorksheetFormat = (orderInventories: OrderInventory[]) => {
       },
       bizplaceName: null,
       startedAt: null,
-      releaseGood: null,
-      binLocationName: uniqueBinLocations.join(', ') // Join multiple bin locations with comma
+      releaseGood: firstReleaseGood
+        ? {
+            id: firstReleaseGood.id,
+            name: firstReleaseGood.name,
+            attentionCompany: firstReleaseGood.attentionCompany,
+            attentionTo: firstReleaseGood.attentionTo,
+            deliveryAddress1: firstReleaseGood.deliveryAddress1,
+            deliveryAddress2: firstReleaseGood.deliveryAddress2,
+            status: firstReleaseGood.status,
+            refNo: firstReleaseGood.refNo,
+            refNo2: firstReleaseGood.refNo2,
+            refNo3: firstReleaseGood.refNo3
+          }
+        : null,
+      binLocationName: uniqueBinLocations.join(', '), // Join multiple bin locations with comma
+      isReleaseGoodScan: !!releaseGood // Flag to indicate if this result came from scanning by release good
     },
     worksheetDetailInfos: orderInventories.map(oi => ({
       id: null,
@@ -96,6 +130,7 @@ const transformToWorksheetFormat = (orderInventories: OrderInventory[]) => {
         id: oi.id,
         batchId: oi.batchId,
         packingType: oi.packingType,
+        refWorksheetId: oi.refWorksheetId,
         product: oi.inventory?.product
           ? {
               id: oi.inventory.product.id,
@@ -132,17 +167,25 @@ export const findLoadableReleaseGoodByBin = {
     if (foundReleaseGood && foundReleaseGood.status == ORDER_STATUS.DONE) {
       throw new OutboundOrderError('This order is DONE', 'ORDER_DONE')
     } else if (foundReleaseGood) {
-      throw new OutboundOrderError(
-        'You are scanning using order number. Your setting for QC by BIN is enabled. Please contact your administrator.',
-        'QC_BY_BIN_ENABLED'
-      )
+      // Found release good by order number - query its order inventories and return worksheet format
+      orderInventoryByBin = await buildOrderInventoryQuery(tx, domain.id, {
+        releaseGoodId: foundReleaseGood.id
+      }).getMany()
+
+      if (orderInventoryByBin.length > 0) {
+        // Pass the release good to indicate this is a release good scan
+        return transformToWorksheetFormat(orderInventoryByBin, foundReleaseGood)
+      } else {
+        throw new OutboundOrderError('There is no item in this order', 'NO_ITEMS_IN_ORDER')
+      }
     } else {
+      // Try to find by bin location
       const binLocation: Location = await tx.getRepository(Location).findOne({
         where: { domain, name: orderNo }
       })
 
       if (binLocation) {
-        orderInventoryByBin = await buildOrderInventoryQuery(tx, domain.id, binLocation.id).getMany()
+        orderInventoryByBin = await buildOrderInventoryQuery(tx, domain.id, { locationId: binLocation.id }).getMany()
       }
 
       if (orderInventoryByBin.length > 0) {

package/server/graphql/resolvers/outbound/find-loadable-release-good.ts

@@ -4,49 +4,126 @@ import { Location } from '@things-factory/warehouse-base'
 import { Domain } from '@things-factory/shell'
 import { OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
 
+/**
+ * Helper function to get all inventory counts in a single query
+ * Returns counts for LOADING status, LOADED status, and total
+ */
+async function getInventoryCounts(
+  tx: EntityManager,
+  domainId: string,
+  releaseGoodId: string,
+  binLocationId?: string
+): Promise<{
+  loadingTotal: number
+  loadingCompleted: number
+  loadedTotal: number
+  loadedCompleted: number
+  total: number
+}> {
+  const qb = tx
+    .getRepository(OrderInventory)
+    .createQueryBuilder('orderInventory')
+    .select('COUNT(*)', 'total')
+    .addSelect(
+      `SUM(CASE WHEN orderInventory.status = :loadingStatus THEN 1 ELSE 0 END)`,
+      'loadingTotal'
+    )
+    .addSelect(
+      `SUM(CASE WHEN orderInventory.status = :loadedStatus THEN 1 ELSE 0 END)`,
+      'loadedTotal'
+    )
+    .where('orderInventory.release_good_id = :releaseGoodId', { releaseGoodId })
+    .andWhere('orderInventory.domain_id = :domainId', { domainId })
+    .setParameter('loadingStatus', ORDER_INVENTORY_STATUS.LOADING)
+    .setParameter('loadedStatus', ORDER_INVENTORY_STATUS.LOADED)
+
+  if (binLocationId) {
+    qb.andWhere('orderInventory.bin_location_id = :binLocationId', { binLocationId })
+  }
+
+  const result = await qb.getRawOne()
+
+  const loadingTotal = parseInt(result.loadingTotal) || 0
+  const loadedTotal = parseInt(result.loadedTotal) || 0
+
+  return {
+    loadingTotal,
+    loadingCompleted: loadedTotal, // Items that moved from LOADING to LOADED
+    loadedTotal,
+    loadedCompleted: loadedTotal, // LOADED items are already complete
+    total: parseInt(result.total) || 0
+  }
+}
+
+/**
+ * Assigns itemCounts and tabCounts to a release good based on inventory counts
+ */
+function assignCountsToReleaseGood(
+  releaseGood: ReleaseGood,
+  counts: Awaited<ReturnType<typeof getInventoryCounts>>,
+  tabName: string,
+  isBinScan: boolean = false
+): void {
+  const { loadingTotal, loadingCompleted, loadedTotal, loadedCompleted, total } = counts
+
+  // Calculate completed count for current tab (backward compatibility)
+  let currentCompleted: number
+  if (isBinScan) {
+    currentCompleted = tabName === 'LOADING' ? loadingTotal : loadedTotal
+  } else {
+    // ORDER scan: QC tab considers LOADING+LOADED as completed
+    currentCompleted = tabName === 'QC' ? loadingTotal + loadedTotal : loadedTotal
+  }
+
+  // Backward compatibility: itemCounts for current tab
+  releaseGood['itemCounts'] = {
+    total,
+    pending: total - currentCompleted
+  }
+
+  // tabCounts for both LOADING and LOADED tabs
+  releaseGood['tabCounts'] = {
+    LOADING: {
+      total: loadingTotal,
+      completed: loadingCompleted,
+      pending: loadingTotal - loadingCompleted
+    },
+    LOADED: {
+      total: loadedTotal,
+      completed: loadedCompleted,
+      pending: loadedTotal - loadedCompleted
+    }
+  }
+}
+
 export const findLoadableReleaseGood = {
   async findLoadableReleaseGood(_: any, { orderNo, tabName }, context: any): Promise<ReleaseGood[]> {
     const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
     let releaseGoods = []
 
-    //put query in util same as find-loadable-release-good-by-bin.ts
-    //jiahhao
     let foundReleaseGood: ReleaseGood = await tx
       .getRepository(ReleaseGood)
       .createQueryBuilder('releaseGood')
       .where('releaseGood.domain_id = :domainId', { domainId: domain.id })
       .andWhere('releaseGood.name = :orderNo', { orderNo })
       .andWhere('releaseGood.status IN (:...status)', {
-        status: [ORDER_STATUS.LOADING, ORDER_STATUS.PROCESSING, ORDER_STATUS.PARTIAL_PROCESSING, ORDER_STATUS.DONE]
+        status: [
+          ORDER_STATUS.SORTING,
+          ORDER_STATUS.LOADING,
+          ORDER_STATUS.PROCESSING,
+          ORDER_STATUS.PARTIAL_PROCESSING,
+          ORDER_STATUS.DONE
+        ]
       })
       .getOne()
 
     if (foundReleaseGood && foundReleaseGood.status == ORDER_STATUS.DONE) {
       throw new Error('This order is DONE')
     } else if (foundReleaseGood) {
-      // Get counts for single release good
-      const counts = await tx
-        .getRepository(OrderInventory)
-        .createQueryBuilder('orderInventory')
-        .select('COUNT(*)', 'total')
-        .addSelect(`SUM(CASE WHEN orderInventory.status IN (:...completedStatuses) THEN 1 ELSE 0 END)`, 'completed')
-        .where('orderInventory.release_good_id = :releaseGoodId', { releaseGoodId: foundReleaseGood.id })
-        .andWhere('orderInventory.domain_id = :domainId', { domainId: domain.id })
-        .setParameter(
-          'completedStatuses',
-          tabName === 'QC'
-            ? [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED]
-            : tabName === 'LOADING'
-            ? [ORDER_INVENTORY_STATUS.LOADED]
-            : [ORDER_INVENTORY_STATUS.LOADED]
-        )
-        .getRawOne()
-
-      foundReleaseGood['itemCounts'] = {
-        total: parseInt(counts.total) || 0,
-        pending: parseInt(counts.completed) || 0
-      }
+      // Get all counts in a single query
+      const counts = await getInventoryCounts(tx, domain.id, foundReleaseGood.id)
+      assignCountsToReleaseGood(foundReleaseGood, counts, tabName, false)
 
       releaseGoods.push(foundReleaseGood)
       return releaseGoods
@@ -56,7 +133,8 @@ export const findLoadableReleaseGood = {
       })
 
       if (binLocation) {
-        // First get all matching release goods
+        // BIN scan: Find all OrderInventory linked to this BIN regardless of status
+        // This allows UI to see orders even when all items are LOADED (so it can auto-switch to LOADED tab)
         const orderInventoryByBin: OrderInventory[] = await tx
           .getRepository(OrderInventory)
           .createQueryBuilder('orderInventory')
@@ -65,18 +143,19 @@ export const findLoadableReleaseGood = {
           .innerJoinAndSelect('bizplace.domain', 'domain')
           .leftJoinAndSelect('releaseGood.sortedBy', 'sortedBy')
           .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-          .andWhere('orderInventory.status = :orderInventoryStatus', {
-            orderInventoryStatus:
-              tabName === 'QC'
-                ? ORDER_INVENTORY_STATUS.SORTING
-                : tabName === 'LOADING'
-                ? ORDER_INVENTORY_STATUS.LOADING
-                : ORDER_INVENTORY_STATUS.LOADED
-          })
           .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
           .andWhere('releaseGood.status IN (:...status)', {
             status: [ORDER_STATUS.LOADING, ORDER_STATUS.PROCESSING, ORDER_STATUS.PARTIAL_PROCESSING]
           })
+          // Include OrderInventory in relevant statuses for loading workflow
+          // This ensures we only get items that are part of the loading process
+          .andWhere('orderInventory.status IN (:...relevantStatuses)', {
+            relevantStatuses: [
+              ORDER_INVENTORY_STATUS.SORTING,
+              ORDER_INVENTORY_STATUS.LOADING,
+              ORDER_INVENTORY_STATUS.LOADED
+            ]
+          })
           .orderBy('releaseGood.createdAt', 'ASC')
           .getMany()
 
@@ -88,39 +167,23 @@ export const findLoadableReleaseGood = {
           return acc
         }, [])
 
-        // Get counts for each release good
+        // Get counts for each release good (scoped to this BIN)
         for (const releaseGood of releaseGoods) {
-          const counts = await tx
-            .getRepository(OrderInventory)
-            .createQueryBuilder('orderInventory')
-            .select('COUNT(*)', 'total')
-            .addSelect(`SUM(CASE WHEN orderInventory.status IN (:...completedStatuses) THEN 1 ELSE 0 END)`, 'completed')
-            .where('orderInventory.release_good_id = :releaseGoodId', { releaseGoodId: releaseGood.id })
-            .andWhere('orderInventory.domain_id = :domainId', { domainId: domain.id })
-            .setParameter(
-              'completedStatuses',
-              tabName === 'LOADING'
-                ? [ORDER_INVENTORY_STATUS.LOADING]
-                : tabName === 'LOADED'
-                ? [ORDER_INVENTORY_STATUS.LOADED]
-                : [ORDER_INVENTORY_STATUS.LOADED]
-            )
-            .getRawOne()
-
-          releaseGood['itemCounts'] = {
-            total: parseInt(counts.total) || 0,
-            pending: parseInt(counts.completed) || 0
-          }
+          const counts = await getInventoryCounts(tx, domain.id, releaseGood.id, binLocation.id)
+          assignCountsToReleaseGood(releaseGood, counts, tabName, true)
         }
       }
 
+      // Return releaseGoods if found, even if LOADING.total=0 (UI will auto-switch to LOADED tab)
+      // Only throw error if BIN has no OrderInventory items at all
       if (releaseGoods.length > 0) return releaseGoods
       else {
+        // No releaseGoods found in this BIN - BIN is empty or has no items in loading workflow
         const errorMessage =
           tabName === 'QC'
             ? 'No items pending QC verification'
             : tabName === 'LOADING'
-            ? 'No items pending loading'
+            ? 'No items found in this bin'
             : 'No items pending dispatch'
         throw new Error(errorMessage)
       }

package/server/graphql/resolvers/outbound/loading-worksheet-v2.ts

@@ -80,7 +80,7 @@ function formatDate(date: Date | null): string | null {
 }
 
 function shouldFilterBySortedQty(releaseGoodStatus: string, disableQC: boolean): boolean {
-  return releaseGoodStatus !== ORDER_STATUS.LOADING || (releaseGoodStatus === ORDER_STATUS.LOADING && !disableQC)
+  return releaseGoodStatus === ORDER_STATUS.LOADING && !disableQC
 }
 
 function getSortedQty(releaseGoodStatus: string, disableQC: boolean, pickedQty: number, sortedQty: number): number {
@@ -154,13 +154,19 @@ export const loadingWorksheetv2 = {
     })
 
     if (filter === FILTER_TYPES.QC) {
-      qb.andWhere('targetInventory.status = :loadingStatus', { loadingStatus: ORDER_INVENTORY_STATUS.SORTING })
+      qb.andWhere('targetInventory.status IN (:...loadingStatus)', {
+        loadingStatus: [ORDER_INVENTORY_STATUS.SORTING, ORDER_INVENTORY_STATUS.LOADING]
+      })
       qb.andWhere('targetInventory.sortedQty <> targetInventory.pickedQty')
     }
 
     if (filter === FILTER_TYPES.LOADING) {
       if (shouldFilterBySortedQty(releaseGood.status, disableQc)) {
         qb.andWhere('targetInventory.sortedQty > 0')
+      } else {
+        qb.andWhere('targetInventory.status IN (:...loadingStatus)', {
+          loadingStatus: [ORDER_INVENTORY_STATUS.SORTING, ORDER_INVENTORY_STATUS.LOADING]
+        })
       }
     }
 
@@ -232,6 +238,7 @@ async function mapdata(
       id: wsd.targetInventory?.id,
       batchId: wsd.targetInventory?.batchId || '-',
       packingType: wsd.targetInventory?.packingType,
+      refWorksheetId: wsd.targetInventory?.refWorksheetId,
       product: {
         id: wsd.targetInventory?.product?.id,
         sku: wsd.targetInventory?.product?.sku,