@things-factory/operato-wms 4.3.760 → 4.3.762

package/client/pages/outbound/loading-v2/delivery-order-info.js

@@ -106,7 +106,7 @@ class DeliveryOrderInfo extends localize(i18next)(LitElement) {
           {
             type: 'row',
             content: [
-              { header: 'Exp Date', field: 'expirationDate', type: 'string' },
+              { header: 'Exp Date', field: 'inventory.expirationDate', type: 'string' },
               { header: 'Batch No', field: 'batchId', type: 'string' }
             ]
           },
@@ -166,6 +166,11 @@ class DeliveryOrderInfo extends localize(i18next)(LitElement) {
 
   async undoLoad() {
     try {
+      // Validate data exists before proceeding
+      if (!this.data?.id) {
+        throw new Error('Delivery order data is not available')
+      }
+
       const result = await CustomAlert({
         title: i18next.t('title.are_you_sure'),
         text: i18next.t('text.proceed_undo_loading'),
@@ -175,23 +180,31 @@ class DeliveryOrderInfo extends localize(i18next)(LitElement) {
 
       if (!result.value) return
 
+      const doId = this.data.id
+
       const response = await client.mutate({
         mutation: gql`
           mutation undoLoad($doId: String!) {
             undoLoad(doId: $doId)
           }
         `,
-        variables: { doId: this.data.id }
+        variables: { doId }
       })
 
       if (!response.errors) {
-        this.dispatchEvent(new CustomEvent('undo', { detail: { doId: this.data.id } }))
-        history.back()
+        // Dispatch event with bubbles and composed to ensure proper propagation through shadow DOM
+        this.dispatchEvent(new CustomEvent('undo', {
+          detail: { doId },
+          bubbles: true,
+          composed: true
+        }))
+        // Small delay to allow event handler to process before closing popup
+        setTimeout(() => history.back(), 100)
       } else {
         throw new Error(response.errors[0]?.message || 'Failed to undo loading')
       }
     } catch (e) {
-      showToast(e)
+      showToast({ type: 'error', message: e.message || 'Failed to undo loading' })
     }
   }
 
@@ -215,8 +228,9 @@ class DeliveryOrderInfo extends localize(i18next)(LitElement) {
     const groupedMap = new Map()
 
     this.data.orderInventories.forEach(oi => {
-      // Create a unique key based on product details
-      const key = `${oi.product?.sku || ''}_${oi.batchId || ''}_${oi.expirationDate || ''}_${oi.packingType || ''}_${oi.packingSize || ''}`
+      // Create a unique key based on product details (expirationDate is on inventory relation)
+      const expirationDate = oi.inventory?.expirationDate || ''
+      const key = `${oi.product?.sku || ''}_${oi.batchId || ''}_${expirationDate}_${oi.packingType || ''}_${oi.packingSize || ''}`
 
       if (groupedMap.has(key)) {
         const existing = groupedMap.get(key)

package/client/pages/outbound/loading-v2/loading-execution-base.js

@@ -448,19 +448,58 @@ export class LoadingExecutionBase extends LitElement {
         throw new Error(i18next.t('text.no_release_order_selected'))
       }
 
+      // Query for minimum seal number setting
+      let minimumSealNumber = 0
+      try {
+        const validationResponse = await client.query({
+          query: VALIDATE_QC_SEALS,
+          variables: { releaseGoodNo: orderNo },
+          context: gqlContext()
+        })
+
+        if (!validationResponse.errors && validationResponse.data?.validateQcSeals) {
+          minimumSealNumber = validationResponse.data.validateQcSeals.minimumSealNumber || 0
+        }
+      } catch (err) {
+        // If query fails, default to 0 (don't block tote scanning)
+        console.warn('Failed to fetch minimum seal number:', err)
+      }
+
       openPopup(
         html`
           <tote-popup
             .orderNo="${orderNo}"
             .toteNo="${this.toteNo}"
             .bizplace="${bizplace}"
+            .minimumSealNumber="${minimumSealNumber}"
             @completed="${async e => {
               this.toteNo = e.detail
               // Check seal status after tote is sealed (may have changed)
               await this._checkAndUpdateSealStatus()
+
+              // Refresh data for both QC and LOADING tabs to reflect any undone items
+              // Use the same logic as validateSorting to determine which order/bin to refresh
+              const orderNoForRefresh = this.worksheet?.isReleaseGoodScan
+                ? this.worksheet?.releaseGood?.name
+                : this._useQcSku
+                ? this.worksheet?.binLocationName
+                : this.worksheet?.releaseGood?.name
+              const useQcSkuForRefresh = this._useQcSku && !this.worksheet?.isReleaseGoodScan
+
+              const [qcData, loadingData] = await Promise.all([
+                this.fetchData(orderNoForRefresh, 'qc', useQcSkuForRefresh),
+                this.fetchData(orderNoForRefresh, 'loading', useQcSkuForRefresh)
+              ])
+
+              // QC tab: items that still need QC (sortedQty < pickedQty)
+              this.qcData = qcData.filter(data => data?.sortedQty < data?.pickedQty) || []
+              // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
+              this.loadingData =
+                loadingData.filter(data => data?.sortedQty >= data?.pickedQty && data.status != WORKSHEET_STATUS.DONE.value) || []
+
               // Update button visibility after sealing (Tote button may need to be hidden if sealing is complete)
               this.getButton()
-              // Update QC banner state after tote is sealed
+              // Update QC banner state after data is refreshed
               if (this._updateQcBannerState) {
                 await this._updateQcBannerState()
               }
@@ -562,9 +601,13 @@ export class LoadingExecutionBase extends LitElement {
         this.fetchData(orderNoForQc, 'qc', useQcSkuForFetch),
         this.fetchData(orderNoForQc, 'loading', useQcSkuForFetch)
       ])
+
+      // QC tab: items that still need QC (sortedQty != pickedQty)
       this.qcData = qcData.filter(data => data?.sortedQty != data?.pickedQty) || []
+      // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
       this.loadingData =
-        loadingData.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+        loadingData.filter(data => data?.sortedQty >= data?.pickedQty && data.status != WORKSHEET_STATUS.DONE.value) || []
+
       // Check seal status when opening QC tab (needed for Tote button visibility)
       await this._checkAndUpdateSealStatus()
       // Update button visibility after fetching QC data (which updates _hasRefWorksheetId)
@@ -585,8 +628,9 @@ export class LoadingExecutionBase extends LitElement {
           // Filter to only show items for the currently selected release order AND from this bin
           // Note: FIND_LOADABLE_RELEASE_GOOD_BY_BIN returns OrderInventory status ('LOADED'),
           // not WorksheetDetail status ('DONE'), so we filter by 'LOADED'
+          // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
           this.loadingData = (binData || []).filter(
-            data => data?.status !== 'LOADED' && data?.releaseGood?.name === this._currentReleaseGood.releaseGood.name
+            data => data?.sortedQty >= data?.pickedQty && data?.status !== 'LOADED' && data?.releaseGood?.name === this._currentReleaseGood.releaseGood.name
           )
         }
 
@@ -617,9 +661,13 @@ export class LoadingExecutionBase extends LitElement {
           }
         }
       } else {
-        this.loadingData = await this.fetchData(this.worksheet?.releaseGood?.name, 'loading', this._useQcSku)
-        // Filter out items that are already LOADED (safety check in case backend returns them)
-        this.loadingData = (this.loadingData || []).filter(data => data?.status !== WORKSHEET_STATUS.DONE.value)
+        const rawLoadingData = await this.fetchData(this.worksheet?.releaseGood?.name, 'loading', this._useQcSku)
+
+        // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
+        this.loadingData = (rawLoadingData || []).filter(
+          data => data?.sortedQty >= data?.pickedQty && data?.status !== WORKSHEET_STATUS.DONE.value
+        )
+
         // Refresh tabCounts when switching to LOADING tab
         if (this._currentReleaseGood?.releaseGood?.name || this.worksheet?.releaseGood?.name) {
           const orderNo = this._currentReleaseGood?.releaseGood?.name || this.worksheet?.releaseGood?.name
@@ -774,13 +822,16 @@ export class LoadingExecutionBase extends LitElement {
 
                 // Filter to only show items for the selected release order from this bin
                 // Note: FIND_LOADABLE_RELEASE_GOOD_BY_BIN returns OrderInventory status ('LOADED')
+                // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
                 this.loadingData = (binData || []).filter(
-                  data => data?.status !== 'LOADED' && data?.releaseGood?.name === selectedRO.name
+                  data => data?.sortedQty >= data?.pickedQty && data?.status !== 'LOADED' && data?.releaseGood?.name === selectedRO.name
                 )
               } else {
                 this.loadingData = await this.fetchData(selectedRO.name, 'loading', false)
-                // Filter out items that are already LOADED (safety check)
-                this.loadingData = (this.loadingData || []).filter(data => data?.status !== WORKSHEET_STATUS.DONE.value)
+                // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
+                this.loadingData = (this.loadingData || []).filter(
+                  data => data?.sortedQty >= data?.pickedQty && data?.status !== WORKSHEET_STATUS.DONE.value
+                )
               }
             } else if (finalTabName === TAB_TYPES.LOADED) {
               this.loadedData = await fetchDeliveryOrders(selectedRO.name)
@@ -801,19 +852,22 @@ export class LoadingExecutionBase extends LitElement {
                     data?.releaseGood?.name === selectedRO.name
                 )
                 // Also fetch loading data for banner
+                // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
                 let binLoadingData = await this.fetchData(this.worksheet.binLocationName, 'loading', true)
                 this.loadingData = (binLoadingData || []).filter(
                   data =>
-                    data?.sortedQty > 0 && data?.status !== 'LOADED' && data?.releaseGood?.name === selectedRO.name
+                    data?.sortedQty >= data?.pickedQty && data?.status !== 'LOADED' && data?.releaseGood?.name === selectedRO.name
                 )
               } else {
                 const [qcData, loadingData] = await Promise.all([
                   this.fetchData(selectedRO.name, 'qc', this._useQcSku),
                   this.fetchData(selectedRO.name, 'loading', this._useQcSku)
                 ])
+                // QC tab: items that still need QC (sortedQty < pickedQty)
                 this.qcData = qcData.filter(data => data?.sortedQty < data?.pickedQty) || []
+                // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
                 this.loadingData =
-                  loadingData.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+                  loadingData.filter(data => data?.sortedQty >= data?.pickedQty && data.status != WORKSHEET_STATUS.DONE.value) || []
               }
               // fetchData updates _hasRefWorksheetId, so update buttons after data is fetched
             }
@@ -873,9 +927,11 @@ export class LoadingExecutionBase extends LitElement {
       )
     }
 
+    // QC tab: items that still need QC (sortedQty < pickedQty)
     this.qcData = this.worksheetDetails.filter(data => data?.sortedQty < data?.pickedQty) || []
+    // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
     this.loadingData =
-      this.worksheetDetails.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+      this.worksheetDetails.filter(data => data?.sortedQty >= data?.pickedQty && data.status != WORKSHEET_STATUS.DONE.value) || []
     this.loadedData = this.deliveryOrdersInfo || []
 
     this._executionData = {
@@ -990,14 +1046,17 @@ export class LoadingExecutionBase extends LitElement {
           let binData = await this.fetchData(this.worksheet.binLocationName, 'loading', true)
           // Filter to only show items for the selected release order from this bin
           // Note: FIND_LOADABLE_RELEASE_GOOD_BY_BIN returns OrderInventory status ('LOADED')
+          // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
           this.loadingData = (binData || []).filter(
-            data => data?.status !== 'LOADED' && data?.releaseGood?.name === orderNo
+            data => data?.sortedQty >= data?.pickedQty && data?.status !== 'LOADED' && data?.releaseGood?.name === orderNo
           )
         } else {
           // Standard mode: fetch by release order name
           this.loadingData = await this.fetchData(orderNo, 'loading', false)
-          // Filter out items that are already LOADED (safety check)
-          this.loadingData = (this.loadingData || []).filter(data => data?.status !== WORKSHEET_STATUS.DONE.value)
+          // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
+          this.loadingData = (this.loadingData || []).filter(
+            data => data?.sortedQty >= data?.pickedQty && data?.status !== WORKSHEET_STATUS.DONE.value
+          )
         }
       }
 
@@ -1240,9 +1299,11 @@ export class LoadingExecutionBase extends LitElement {
           this.fetchData(orderNoForRefresh, 'loading', useQcSkuForRefresh)
         ])
 
+        // QC tab: items that still need QC (sortedQty < pickedQty)
         this.qcData = qcData.filter(data => data?.sortedQty < data?.pickedQty) || []
+        // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
         this.loadingData =
-          loadingData.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+          loadingData.filter(data => data?.sortedQty >= data?.pickedQty && data.status != WORKSHEET_STATUS.DONE.value) || []
 
         // Update QC banner state after data changes
         if (this._updateQcBannerState) {
@@ -1493,8 +1554,10 @@ export class LoadingExecutionBase extends LitElement {
           @warehouse-return=${async e => {
             showToast({ type: 'success', message: 'Returning worksheet generated' })
             this.loadingData = await this.fetchData(this.worksheet?.releaseGood?.name, 'loading', this._useQcSku)
-            // Filter out items that are already LOADED (safety check)
-            this.loadingData = (this.loadingData || []).filter(data => data?.status !== WORKSHEET_STATUS.DONE.value)
+            // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
+            this.loadingData = (this.loadingData || []).filter(
+              data => data?.sortedQty >= data?.pickedQty && data?.status !== WORKSHEET_STATUS.DONE.value
+            )
           }}
         ></warehouse-return-popup>
       `,
@@ -1557,6 +1620,7 @@ export class LoadingExecutionBase extends LitElement {
           }
 
           const worksheetDetailInfos = response.data.loadingWorksheetv2.worksheetDetailInfos
+
           // Check if any order inventory has refWorksheetId
           this._hasRefWorksheetId = worksheetDetailInfos.some(
             item => item?.relatedOrderInv?.refWorksheetId != null && item?.relatedOrderInv?.refWorksheetId !== ''

package/client/pages/outbound/loading-v2/loading-execution.js

@@ -424,9 +424,11 @@ export class LoadingExecution extends LoadingExecutionBase {
     }
 
     // Filter data for different tabs
+    // QC tab: items that still need QC (sortedQty < pickedQty)
     this.qcData = processedDetails.filter(data => data?.sortedQty < data?.pickedQty && data.status !== 'LOADED') || []
+    // Loading tab: items that have completed QC (sortedQty >= pickedQty) and are not yet loaded
     this.loadingData =
-      processedDetails.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+      processedDetails.filter(data => data?.sortedQty >= data?.pickedQty && data.status != WORKSHEET_STATUS.DONE.value) || []
     this.loadedData = this.deliveryOrdersInfo || []
 
     // Update execution data

package/client/pages/outbound/picking-product.js

@@ -33,6 +33,17 @@ import {
 } from '../constants'
 
 const PICKING_TYPES = { PICKING, BATCH_PICKING }
+
+const VALIDATE_QC_SEALS = gql`
+  query validateQcSeals($releaseGoodNo: String!) {
+    validateQcSeals(releaseGoodNo: $releaseGoodNo) {
+      valid
+      error
+      minimumSealNumber
+    }
+  }
+`
+
 class PickingProduct extends connect(store)(localize(i18next)(PageView)) {
   static get properties() {
     return {
@@ -976,14 +987,37 @@ class PickingProduct extends connect(store)(localize(i18next)(PageView)) {
 
   async openTotePopup() {
     await sleep(1010)
+
+    // Query for minimum seal number setting
+    let minimumSealNumber = 0
+    try {
+      const validationResponse = await client.query({
+        query: VALIDATE_QC_SEALS,
+        variables: { releaseGoodNo: this.releaseGoodNo },
+        context: gqlContext()
+      })
+
+      if (!validationResponse.errors && validationResponse.data?.validateQcSeals) {
+        minimumSealNumber = validationResponse.data.validateQcSeals.minimumSealNumber || 0
+      }
+    } catch (err) {
+      // If query fails, default to 0 (don't block tote scanning)
+      console.warn('Failed to fetch minimum seal number:', err)
+    }
+
     openPopup(
       html`
         <tote-popup
           .orderNo="${this.releaseGoodNo}"
           .toteNo="${this.toteNo}"
           .bizplace="${this._bizplaceName}"
+          .minimumSealNumber="${minimumSealNumber}"
           @completed="${async e => {
             this.toteNo = e.detail
+            // Refresh the item list to reflect any undone items
+            await this.fetchInventories(
+              this.refPickingType === PICKING_TYPES.PICKING.value ? this.releaseGoodNo : this.taskNo
+            )
           }}"
         ></tote-popup>
       `,

package/client/pages/outbound/sorting-product.js

@@ -21,6 +21,16 @@ import { fetchSettingRule } from '../../fetch-setting-value'
 import { WORKSHEET_STATUS } from '../constants'
 import { decodeQR, fetchPageSettings, isValidHttpUrl } from '../../util'
 
+const VALIDATE_QC_SEALS = gql`
+  query validateQcSeals($releaseGoodNo: String!) {
+    validateQcSeals(releaseGoodNo: $releaseGoodNo) {
+      valid
+      error
+      minimumSealNumber
+    }
+  }
+`
+
 class SortingProduct extends connect(store)(localize(i18next)(PageView)) {
   static get properties() {
     return {
@@ -515,14 +525,34 @@ class SortingProduct extends connect(store)(localize(i18next)(PageView)) {
 
   async _openTotePopup() {
     await sleep(1010)
+
+    // Query for minimum seal number setting
+    let minimumSealNumber = 0
+    try {
+      const validationResponse = await client.query({
+        query: VALIDATE_QC_SEALS,
+        variables: { releaseGoodNo: this._selectedReleaseGood }
+      })
+
+      if (!validationResponse.errors && validationResponse.data?.validateQcSeals) {
+        minimumSealNumber = validationResponse.data.validateQcSeals.minimumSealNumber || 0
+      }
+    } catch (err) {
+      // If query fails, default to 0 (don't block tote scanning)
+      console.warn('Failed to fetch minimum seal number:', err)
+    }
+
     openPopup(
       html`
         <tote-popup
           .orderNo="${this._selectedReleaseGood}"
           .toteNo="${this.toteNo}"
           .bizplace="${this.bizplaceName}"
+          .minimumSealNumber="${minimumSealNumber}"
           @completed="${async e => {
             this.toteNo = e.detail
+            // Refresh the item list to reflect any undone items
+            await this._fetchItemList(this._selectedReleaseGood)
           }}"
         ></tote-popup>
       `,