@things-factory/operato-wms 4.3.752 → 4.3.755

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

@@ -4,6 +4,7 @@ import './release-good-info'
 import './delivery-order-info'
 import '../show-ro-list-popup'
 import '../transport-vehicles-popup'
+import '../tote-popup'
 import './load-by-qty'
 import './warehouse-return-popup'
 
@@ -21,7 +22,8 @@ import { showToast } from '../../../util'
 // Constants
 const SETTINGS = {
   QC_SKU: 'qc-sku',
-  DISABLE_QC: 'disable-QC-in-loading'
+  DISABLE_QC: 'disable-QC-in-loading',
+  ENABLE_TOTE_SCANNING: 'enable-tote-scanning'
 }
 
 const TAB_TYPES = {
@@ -51,6 +53,18 @@ const FIND_LOADABLE_RELEASE_GOOD = gql`
         total
         pending
       }
+      tabCounts {
+        LOADING {
+          total
+          completed
+          pending
+        }
+        LOADED {
+          total
+          completed
+          pending
+        }
+      }
     }
   }
 `
@@ -58,6 +72,22 @@ const FIND_LOADABLE_RELEASE_GOOD = gql`
 const FIND_LOADABLE_RELEASE_GOOD_BY_BIN = gql`
   query findLoadableReleaseGoodByBin($orderNo: String!) {
     findLoadableReleaseGoodByBin(orderNo: $orderNo) {
+      worksheetInfo {
+        binLocationName
+        isReleaseGoodScan
+        releaseGood {
+          id
+          name
+          attentionCompany
+          attentionTo
+          deliveryAddress1
+          deliveryAddress2
+          status
+          refNo
+          refNo2
+          refNo3
+        }
+      }
       worksheetDetailInfos {
         id
         name
@@ -90,6 +120,7 @@ const FIND_LOADABLE_RELEASE_GOOD_BY_BIN = gql`
           id
           batchId
           packingType
+          refWorksheetId
           product {
             id
             sku
@@ -150,6 +181,7 @@ const LOADING_WORKSHEET_V2 = gql`
           id
           batchId
           packingType
+          refWorksheetId
           product {
             id
             sku
@@ -191,12 +223,19 @@ const GET_DELIVERY_ORDERS = gql`
 `
 
 const SORT_ITEM = gql`
-  mutation sortItem($releaseGoodNo: String!, $productBarcode: String!, $qty: Float!, $worksheetDetails: [Object!]) {
+  mutation sortItem(
+    $releaseGoodNo: String!
+    $productBarcode: String!
+    $qty: Float!
+    $worksheetDetails: [Object!]
+    $toteNo: String
+  ) {
     sortItem(
       releaseGoodNo: $releaseGoodNo
       productBarcode: $productBarcode
       qty: $qty
       worksheetDetails: $worksheetDetails
+      toteNo: $toteNo
     )
   }
 `
@@ -213,6 +252,16 @@ const COMPLETE_LOAD_PARTIALLY = gql`
   }
 `
 
+const VALIDATE_QC_SEALS = gql`
+  query validateQcSeals($releaseGoodNo: String!) {
+    validateQcSeals(releaseGoodNo: $releaseGoodNo) {
+      valid
+      error
+      minimumSealNumber
+    }
+  }
+`
+
 export class LoadingExecutionBase extends LitElement {
   static get properties() {
     return {
@@ -237,13 +286,24 @@ export class LoadingExecutionBase extends LitElement {
       loadedData: Array,
       _executionData: Object,
       _disableQC: Boolean,
-      _useQcSku: Boolean
+      _useQcSku: Boolean,
+      _enableToteScanning: Boolean,
+      _enableToteScanningValue: Number,
+      _hasRefWorksheetId: Boolean,
+      toteNo: String,
+      _tabCounts: Object,
+      _needsSealing: Boolean
     }
   }
 
   constructor() {
     super()
     this._useQcSku = false
+    this._enableToteScanning = false
+    this._enableToteScanningValue = 0
+    this._hasRefWorksheetId = false
+    this.toteNo = ''
+    this._needsSealing = false
     this._worksheetState = null
     this._executionData = {
       ownCollection: false,
@@ -332,7 +392,12 @@ export class LoadingExecutionBase extends LitElement {
       title: i18next.t('button.order_list'),
       action: async () => {
         try {
-          const orderNo = this._useQcSku ? this.worksheet?.binLocationName : this.worksheet?.releaseGood?.name
+          // If isReleaseGoodScan is true, use release good name; otherwise use binLocationName if QC SKU mode
+          const orderNo = this.worksheet?.isReleaseGoodScan
+            ? this.worksheet?.releaseGood?.name
+            : this._useQcSku
+            ? this.worksheet?.binLocationName
+            : this.worksheet?.releaseGood?.name
 
           if (!orderNo) {
             throw new Error(i18next.t('text.no_order_selected'))
@@ -344,7 +409,8 @@ export class LoadingExecutionBase extends LitElement {
               orderNo,
               tabName: this.state?.activeTab || TAB_TYPES.LOADING
             },
-            context: gqlContext()
+            context: gqlContext(),
+            fetchPolicy: 'network-only' // Always fetch fresh data to show updated item counts
           })
 
           if (!response.errors) {
@@ -363,6 +429,57 @@ export class LoadingExecutionBase extends LitElement {
     }
   }
 
+  get toteButton() {
+    return {
+      title: i18next.t('button.tote'),
+      action: async () => {
+        await this.openTotePopup()
+      },
+      ...CommonButtonStyles.activate
+    }
+  }
+
+  async openTotePopup() {
+    try {
+      const orderNo = this._currentReleaseGood?.releaseGood?.name
+      const bizplace = this._currentReleaseGood?.bizplaceName
+
+      if (!orderNo) {
+        throw new Error(i18next.t('text.no_release_order_selected'))
+      }
+
+      openPopup(
+        html`
+          <tote-popup
+            .orderNo="${orderNo}"
+            .toteNo="${this.toteNo}"
+            .bizplace="${bizplace}"
+            @completed="${async e => {
+              this.toteNo = e.detail
+              // Check seal status after tote is sealed (may have changed)
+              await this._checkAndUpdateSealStatus()
+              // 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
+              if (this._updateQcBannerState) {
+                await this._updateQcBannerState()
+              }
+            }}"
+          ></tote-popup>
+        `,
+        {
+          closable: false,
+          backdrop: false,
+          escapable: false,
+          size: 'large',
+          title: i18next.t('title.tote_scanning')
+        }
+      )
+    } catch (e) {
+      showToast(e)
+    }
+  }
+
   // Input Getters
   get productBarcodeInput() {
     return this.shadowRoot
@@ -396,30 +513,86 @@ export class LoadingExecutionBase extends LitElement {
 
   // Core Methods
   async openTab(e, tabName) {
+    // Validate seals before allowing switch to LOADING tab
+    // Validation applies when tote scanning is enabled and switching from QC or LOADED to LOADING
+    // The validation query checks if totes exist and are properly sealed based on minimum-seal-number
+    if (
+      tabName === TAB_TYPES.LOADING &&
+      (this.state?.activeTab === TAB_TYPES.QC || this.state?.activeTab === TAB_TYPES.LOADED) &&
+      this._enableToteScanning
+    ) {
+      const orderNo = this._currentReleaseGood?.releaseGood?.name || this.worksheet?.releaseGood?.name
+      if (orderNo) {
+        try {
+          const validationResponse = await client.query({
+            query: VALIDATE_QC_SEALS,
+            variables: { releaseGoodNo: orderNo },
+            context: gqlContext()
+          })
+
+          if (!validationResponse.errors && validationResponse.data?.validateQcSeals) {
+            const { valid, error, minimumSealNumber } = validationResponse.data.validateQcSeals
+            // Only block if valid is false AND minimumSealNumber > 0
+            // If minimumSealNumber is 0, allow switching even if valid is false
+            if (!valid && (minimumSealNumber || 0) > 0) {
+              throw new Error(error || 'Seal validation failed')
+            }
+          }
+        } catch (e) {
+          showToast(e)
+          // Don't change tab on validation failure
+          return
+        }
+      }
+    }
+
     this.state = { ...this.state, activeTab: tabName }
     await this.updateComplete
 
     if (tabName === TAB_TYPES.QC) {
-      const qcData = await this.fetchData(
-        this._useQcSku ? this.worksheet?.binLocationName : this.worksheet?.releaseGood?.name,
-        'qc',
-        this._useQcSku
-      )
+      // If isReleaseGoodScan is true, use release good name; otherwise use binLocationName if QC SKU mode
+      const orderNoForQc = this.worksheet?.isReleaseGoodScan
+        ? this.worksheet?.releaseGood?.name
+        : this._useQcSku
+        ? this.worksheet?.binLocationName
+        : this.worksheet?.releaseGood?.name
+      const useQcSkuForFetch = this._useQcSku && !this.worksheet?.isReleaseGoodScan
+      // Fetch both QC and LOADING data so banner can check if items are ready for loading
+      const [qcData, loadingData] = await Promise.all([
+        this.fetchData(orderNoForQc, 'qc', useQcSkuForFetch),
+        this.fetchData(orderNoForQc, 'loading', useQcSkuForFetch)
+      ])
       this.qcData = qcData.filter(data => data?.sortedQty != data?.pickedQty) || []
+      this.loadingData =
+        loadingData.filter(data => data?.sortedQty > 0 && 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)
+      this.getButton()
+      // Update QC banner state after fetching QC data
+      if (this._updateQcBannerState) {
+        await this._updateQcBannerState()
+      }
     } else if (tabName === TAB_TYPES.LOADING) {
-      if (this._useQcSku && this.worksheet?.binLocationName) {
+      // Use bin-based query only if QC SKU mode AND it's not a release good scan
+      if (this._useQcSku && this.worksheet?.binLocationName && !this.worksheet?.isReleaseGoodScan) {
         const response = await client.query({
           query: FIND_LOADABLE_RELEASE_GOOD,
           variables: {
             orderNo: this.worksheet?.binLocationName,
             tabName: this.state?.activeTab || TAB_TYPES.LOADING
           },
-          context: gqlContext()
+          context: gqlContext(),
+          fetchPolicy: 'network-only' // Always fetch fresh data to show updated item counts
         })
 
         if (!response.errors) {
           let records = response.data.findLoadableReleaseGood
           if (records.length) {
+            // Store tabCounts from first record if available
+            if (records[0]?.tabCounts) {
+              this._tabCounts = records[0].tabCounts
+            }
             await this.selectReleaseOrderPopup(records, this.state?.activeTab)
             if (this.state.activeTab !== TAB_TYPES.LOADING) {
               this.state = { ...this.state, activeTab: TAB_TYPES.LOADING }
@@ -431,9 +604,50 @@ export class LoadingExecutionBase extends LitElement {
         }
       } else {
         this.loadingData = await this.fetchData(this.worksheet?.releaseGood?.name, 'loading', this._useQcSku)
+        // 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
+          try {
+            const response = await client.query({
+              query: FIND_LOADABLE_RELEASE_GOOD,
+              variables: {
+                orderNo,
+                tabName: TAB_TYPES.LOADING
+              },
+              context: gqlContext(),
+              fetchPolicy: 'network-only' // Always fetch fresh data to show updated counts
+            })
+            if (!response.errors && response.data.findLoadableReleaseGood.length > 0) {
+              const releaseGood = response.data.findLoadableReleaseGood[0]
+              if (releaseGood.tabCounts) {
+                this._tabCounts = releaseGood.tabCounts
+              }
+            }
+          } catch (e) {
+            console.error('Error refreshing tabCounts:', e)
+          }
+        }
       }
     } else if (tabName === TAB_TYPES.LOADED) {
-      if (!this._currentReleaseGood?.releaseGood?.name || this._useQcSku) {
+      // Ensure _currentReleaseGood is set from worksheet if not already set
+      if (!this._currentReleaseGood?.releaseGood?.name && this.worksheet?.releaseGood?.name) {
+        this._currentReleaseGood = {
+          releaseGood: this.worksheet.releaseGood,
+          bizplaceName: this.worksheet?.bizplaceName,
+          startedAt: this.worksheet?.startedAt
+        }
+      }
+
+      // If we have a current release good, use reload() which works with order number (no bin required)
+      if (this._currentReleaseGood?.releaseGood?.name) {
+        await this.reload()
+        // reload() already calls getButton(), so we can return here
+        return
+      }
+
+      // If using QC SKU mode and need to query by bin -> require bin location
+      // Only enforce bin selection when actually needed for bin-based operations
+      if (this._useQcSku) {
         if (!this.worksheet?.binLocationName) {
           throw new Error(i18next.t('text.no_bin_location_selected'))
         }
@@ -444,27 +658,33 @@ export class LoadingExecutionBase extends LitElement {
             orderNo: this.worksheet.binLocationName,
             tabName: this.state?.activeTab || TAB_TYPES.LOADED
           },
-          context: gqlContext()
+          context: gqlContext(),
+          fetchPolicy: 'network-only' // Always fetch fresh data to show updated item counts
         })
 
         if (!response.errors) {
           let records = response.data.findLoadableReleaseGood
           if (records.length) {
-            await this.selectReleaseOrderPopup(records, this.state?.activeTab)
-            if (this._currentReleaseGood?.releaseGood?.name) {
-              this.loadedData = await fetchDeliveryOrders(this._currentReleaseGood?.releaseGood?.name)
-              if (!this.worksheet?.worksheet?.id) {
-                await this.fetchData(this._currentReleaseGood.releaseGood.name, 'loading', this._useQcSku)
-              }
+            // Store tabCounts from first record if available
+            if (records[0]?.tabCounts) {
+              this._tabCounts = records[0].tabCounts
             }
+            await this.selectReleaseOrderPopup(records, this.state?.activeTab)
+            // selectReleaseOrderPopup will handle data fetch and getButton() call
+            return
           } else {
             throw new Error(i18next.t('text.no_release_order_found'))
           }
         }
       } else {
-        this.loadedData = await fetchDeliveryOrders(this._currentReleaseGood?.releaseGood?.name)
-        if (!this.worksheet?.worksheet?.id) {
-          await this.fetchData(this._currentReleaseGood.releaseGood.name, 'loading', this._useQcSku)
+        // Not using QC SKU mode and no current release good -> try to use order number from worksheet
+        // Allow switching to LOADED tab even without bin selection
+        if (this.worksheet?.releaseGood?.name) {
+          await this.reload()
+          return
+        } else {
+          // No order selected at all -> show error
+          throw new Error(i18next.t('text.no_release_order_selected'))
         }
       }
     }
@@ -498,27 +718,66 @@ export class LoadingExecutionBase extends LitElement {
               startedAt: this.worksheet?.startedAt
             }
 
+            // Reset tote selection when switching RO
+            this.toteNo = ''
+            // Reset refWorksheetId flag - will be updated when data is fetched
+            this._hasRefWorksheetId = false
+            // Reset seal status - will be updated after data is fetched
+            this._needsSealing = false
+
             this._executionData = {
               ...this._executionData,
               orderId: selectedRO.id
             }
 
-            this.state = { ...this.state, activeTab: tabName }
+            // Store tabCounts for banner display
+            if (selectedRO.tabCounts) {
+              this._tabCounts = selectedRO.tabCounts
+            }
+
+            // UX-safe tab selection: Auto-switch to LOADED if LOADING is empty but LOADED has items
+            let finalTabName = tabName
+            if (selectedRO.tabCounts) {
+              const loadingCounts = selectedRO.tabCounts.LOADING || { total: 0, pending: 0 }
+              const loadedCounts = selectedRO.tabCounts.LOADED || { total: 0, pending: 0 }
+
+              // If current tab is LOADING and it's empty, but LOADED has items, switch to LOADED
+              if (tabName === TAB_TYPES.LOADING && loadingCounts.total === 0 && loadedCounts.total > 0) {
+                finalTabName = TAB_TYPES.LOADED
+              }
+            }
+
+            this.state = { ...this.state, activeTab: finalTabName }
             await this.updateComplete
 
-            if (tabName === TAB_TYPES.LOADING) {
+            if (finalTabName === TAB_TYPES.LOADING) {
               this.loadingData = await this.fetchData(selectedRO.name, 'loading', false)
-            } else if (tabName === TAB_TYPES.LOADED) {
+            } else if (finalTabName === TAB_TYPES.LOADED) {
               this.loadedData = await fetchDeliveryOrders(selectedRO.name)
               if (!this.worksheet?.worksheet?.id) {
                 await this.fetchData(selectedRO.name, 'loading', this._useQcSku)
               }
-            } else if (tabName === TAB_TYPES.QC) {
-              this.qcData = await this.fetchData(selectedRO.name, 'qc', this._useQcSku)
+            } else if (finalTabName === TAB_TYPES.QC) {
+              // Fetch both QC and LOADING data so banner can check if items are ready for loading
+              const [qcData, loadingData] = await Promise.all([
+                this.fetchData(selectedRO.name, 'qc', this._useQcSku),
+                this.fetchData(selectedRO.name, 'loading', this._useQcSku)
+              ])
+              this.qcData = qcData.filter(data => data?.sortedQty < data?.pickedQty) || []
+              this.loadingData =
+                loadingData.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+              // fetchData updates _hasRefWorksheetId, so update buttons after data is fetched
             }
 
             await this.updateComplete
+            // Check seal status after order is selected (needed for Tote button visibility)
+            await this._checkAndUpdateSealStatus()
+            // Update button visibility after data is fetched (which updates _hasRefWorksheetId)
             this.getButton()
+            // Update QC banner state after data is fetched
+            if (this._updateQcBannerState) {
+              await this._updateQcBannerState()
+            }
           }}
         ></show-ro-list-popup>
       `,
@@ -546,6 +805,8 @@ export class LoadingExecutionBase extends LitElement {
   async resetView() {
     this._disableQC = await fetchSettingRule(SETTINGS.DISABLE_QC)
     this._useQcSku = await fetchSettingRule(SETTINGS.QC_SKU)
+    this._enableToteScanningValue = parseInt((await fetchSettingRule(SETTINGS.ENABLE_TOTE_SCANNING)) || '0', 10)
+    this._enableToteScanning = this._enableToteScanningValue >= 1
 
     let activeTab = TAB_TYPES.QC
     if (this._disableQC && !this._useQcSku) {
@@ -556,7 +817,14 @@ export class LoadingExecutionBase extends LitElement {
 
     const currentWorksheet = this.worksheet
 
-    this.qcData = this.worksheetDetails.filter(data => data?.sortedQty != data?.pickedQty) || []
+    // Check if any order inventory has refWorksheetId (when data comes from props)
+    if (this.worksheetDetails && this.worksheetDetails.length > 0) {
+      this._hasRefWorksheetId = this.worksheetDetails.some(
+        item => item?.relatedOrderInv?.refWorksheetId != null && item?.relatedOrderInv?.refWorksheetId !== ''
+      )
+    }
+
+    this.qcData = this.worksheetDetails.filter(data => data?.sortedQty < data?.pickedQty) || []
     this.loadingData =
       this.worksheetDetails.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
     this.loadedData = this.deliveryOrdersInfo || []
@@ -567,6 +835,9 @@ export class LoadingExecutionBase extends LitElement {
       worksheetId: currentWorksheet?.worksheet?.id
     }
 
+    // reset tote when resetting view
+    this.toteNo = ''
+
     if (!this.worksheet && this.worksheetDetails?.length > 0) {
       this.worksheet = {
         ...currentWorksheet,
@@ -577,10 +848,175 @@ export class LoadingExecutionBase extends LitElement {
     this.getButton()
   }
 
+  /**
+   * Reloads all data and counts after mutations (load, undo, etc.)
+   * This ensures banner and button visibility are always accurate
+   * Always fetches counts for BOTH LOADING and LOADED tabs
+   */
+  async reload() {
+    // If no order selected, clear stale state and show error
+    if (!this._currentReleaseGood?.releaseGood?.name && !this.worksheet?.releaseGood?.name) {
+      // Clear stale state to prevent incorrect UI
+      this._tabCounts = null
+      this.loadedData = null
+      showToast({ type: 'error', message: i18next.t('text.no_release_order_selected') })
+      this.getButton()
+      return
+    }
+
+    const orderNo = this._currentReleaseGood?.releaseGood?.name || this.worksheet?.releaseGood?.name
+
+    try {
+      // Query for BOTH LOADING and LOADED tabs to ensure complete tabCounts
+      const [loadingResponse, loadedResponse] = await Promise.all([
+        client.query({
+          query: FIND_LOADABLE_RELEASE_GOOD,
+          variables: {
+            orderNo,
+            tabName: TAB_TYPES.LOADING
+          },
+          context: gqlContext(),
+          fetchPolicy: 'network-only' // Always fetch fresh data to show updated counts
+        }),
+        client.query({
+          query: FIND_LOADABLE_RELEASE_GOOD,
+          variables: {
+            orderNo,
+            tabName: TAB_TYPES.LOADED
+          },
+          context: gqlContext(),
+          fetchPolicy: 'network-only' // Always fetch fresh data to show updated counts
+        })
+      ])
+
+      // Merge tabCounts from both queries
+      let mergedTabCounts = {
+        LOADING: null,
+        LOADED: null
+      }
+
+      // Extract LOADING counts
+      if (!loadingResponse.errors && loadingResponse.data.findLoadableReleaseGood.length > 0) {
+        const loadingReleaseGood = loadingResponse.data.findLoadableReleaseGood[0]
+        if (loadingReleaseGood.tabCounts?.LOADING) {
+          mergedTabCounts.LOADING = loadingReleaseGood.tabCounts.LOADING
+        }
+        // Also get LOADED counts from LOADING query if available (backend returns both)
+        if (loadingReleaseGood.tabCounts?.LOADED) {
+          mergedTabCounts.LOADED = loadingReleaseGood.tabCounts.LOADED
+        }
+      }
+
+      // Extract LOADED counts (prefer from LOADED query if LOADING query didn't have it)
+      if (!loadedResponse.errors && loadedResponse.data.findLoadableReleaseGood.length > 0) {
+        const loadedReleaseGood = loadedResponse.data.findLoadableReleaseGood[0]
+        if (loadedReleaseGood.tabCounts?.LOADED) {
+          mergedTabCounts.LOADED = loadedReleaseGood.tabCounts.LOADED
+        }
+        // Also get LOADING counts from LOADED query if available (backend returns both)
+        if (loadedReleaseGood.tabCounts?.LOADING && !mergedTabCounts.LOADING) {
+          mergedTabCounts.LOADING = loadedReleaseGood.tabCounts.LOADING
+        }
+      }
+
+      // Set merged tabCounts (only if we got at least one count)
+      if (mergedTabCounts.LOADING || mergedTabCounts.LOADED) {
+        this._tabCounts = mergedTabCounts
+      } else {
+        // Both queries returned empty or had errors - clear stale tabCounts
+        this._tabCounts = null
+      }
+
+      // Refresh loadedData
+      if (orderNo) {
+        this.loadedData = await fetchDeliveryOrders(orderNo)
+      }
+
+      // Always refresh loadingData (not just when on LOADING tab)
+      // This ensures banner condition (which uses loadingData.length) is accurate after undo/load mutations
+      // If a release good is selected (from popup), use release good query, not bin query
+      if (orderNo) {
+        const useQcSkuForReload =
+          this._useQcSku && !this.worksheet?.isReleaseGoodScan && !this._currentReleaseGood?.releaseGood?.name
+        this.loadingData = await this.fetchData(orderNo, 'loading', useQcSkuForReload)
+      }
+
+      // Update button visibility
+      await this.updateComplete
+      this.getButton()
+
+      // Update QC banner state after reload (in case we're on QC tab)
+      if (this._updateQcBannerState) {
+        await this._updateQcBannerState()
+      }
+
+      // Request update to refresh banner visibility after data reload
+      this.requestUpdate()
+    } catch (e) {
+      console.error('Error reloading data:', e)
+      // Clear stale state on error to prevent incorrect UI
+      this._tabCounts = null
+      this.loadedData = null
+      showToast({
+        type: 'error',
+        message: i18next.t('text.failed_to_refresh_data', { defaultValue: 'Failed to refresh data' })
+      })
+      this.getButton()
+    }
+  }
+
+  /**
+   * Checks if sealing is needed and updates _needsSealing property
+   * This can be overridden by child classes to provide custom seal checking logic
+   */
+  async _checkAndUpdateSealStatus() {
+    if (!this._enableToteScanning) {
+      this._needsSealing = false
+      return
+    }
+
+    const orderNo = this._currentReleaseGood?.releaseGood?.name || this.worksheet?.releaseGood?.name
+    if (!orderNo) {
+      this._needsSealing = false
+      return
+    }
+
+    try {
+      const validationResponse = await client.query({
+        query: VALIDATE_QC_SEALS,
+        variables: { releaseGoodNo: orderNo },
+        context: gqlContext()
+      })
+
+      if (!validationResponse.errors && validationResponse.data?.validateQcSeals) {
+        const { valid, minimumSealNumber } = validationResponse.data.validateQcSeals
+        const minSealNum = minimumSealNumber || 0
+        // Sealing is needed if valid is false AND minimumSealNumber > 0
+        this._needsSealing = !valid && minSealNum > 0
+      } else {
+        this._needsSealing = false
+      }
+    } catch (e) {
+      // On error, assume sealing might be needed to be safe
+      this._needsSealing = true
+    }
+  }
+
   getButton() {
     let activeTab = this.state?.activeTab
 
     let buttons = [this.backButton]
+    // Tote button visibility logic for QC tab:
+    if (activeTab === TAB_TYPES.QC && this._enableToteScanning && this._useQcSku === false) {
+      const shouldShowToteButton =
+        (this._disableQC === false && this._hasRefWorksheetId) ||
+        (this._disableQC === false && this._enableToteScanningValue === 2 && !this._hasRefWorksheetId) ||
+        this._needsSealing === true
+
+      if (shouldShowToteButton) {
+        buttons.unshift(this.toteButton)
+      }
+    }
     if (activeTab === TAB_TYPES.LOADING) {
       if (this.loadingData?.length > 0) {
         if (this._useQcSku) {
@@ -593,10 +1029,20 @@ export class LoadingExecutionBase extends LitElement {
       if (this._useQcSku) {
         buttons.unshift(this.orderListButton)
       }
-      if (this.loadedData?.completable) {
+      // Show COMPLETE button based on:
+      // 1. Prefer _tabCounts.LOADED.total > 0 (most reliable)
+      // 2. Only block if loadedData.completable === false explicitly
+      // 3. Also check loadedData.deliveryOrders as fallback
+      const hasLoadedItems =
+        this._tabCounts?.LOADED?.total > 0 ||
+        (this.loadedData?.deliveryOrders && this.loadedData.deliveryOrders.length > 0)
+      const canComplete = this.loadedData?.completable !== false
+
+      if (hasLoadedItems && canComplete) {
         buttons.unshift(this.completeButton)
       } else if (
-        this.loadedData?.deliveryOrders.length > 0 &&
+        this.loadedData?.deliveryOrders &&
+        this.loadedData.deliveryOrders.length > 0 &&
         this._currentReleaseGood?.releaseGood?.status !== 'LOADING'
       ) {
         buttons.unshift(this.partialButton)
@@ -665,7 +1111,8 @@ export class LoadingExecutionBase extends LitElement {
           .data="${targetDO}"
           @undo=${async e => {
             showToast({ type: 'success', message: 'undo loading completed' })
-            this.loadedData = await fetchDeliveryOrders(this._currentReleaseGood.releaseGood.name)
+            // Reload all data and counts to update banner and button visibility
+            await this.reload()
           }}
         ></delivery-order-info>
       `,
@@ -685,13 +1132,21 @@ export class LoadingExecutionBase extends LitElement {
       await this.validateSorting()
       let selectedData = this.qcData.filter(data => this.qcDataView.selectedItems.includes(data.id))
 
+      // If isReleaseGoodScan is true, use release good name; otherwise use binLocationName if QC SKU mode
+      const releaseGoodNo = this.worksheet?.isReleaseGoodScan
+        ? this.worksheet?.releaseGood?.name
+        : this._useQcSku
+        ? this.worksheet?.binLocationName
+        : this.worksheet?.releaseGood?.name
+
       const response = await client.mutate({
         mutation: SORT_ITEM,
         variables: {
-          releaseGoodNo: this._useQcSku ? this.worksheet?.binLocationName : this.worksheet?.releaseGood?.name,
+          releaseGoodNo,
           productBarcode: this.productBarcodeInput.value,
           qty: parseFloat(this.qtyInput.value),
-          worksheetDetails: selectedData
+          worksheetDetails: selectedData,
+          toteNo: this._enableToteScanning && this.toteNo !== '' ? this.toteNo : null
         }
       })
 
@@ -700,13 +1155,28 @@ export class LoadingExecutionBase extends LitElement {
         this.qtyInput.value = ''
         this._focusOnProductBarcodeInput()
 
-        const updatedData = await this.fetchData(
-          this._useQcSku ? this.worksheet?.binLocationName : this.worksheet?.releaseGood?.name,
-          'qc',
-          this._useQcSku
-        )
-
-        this.qcData = updatedData.filter(data => data?.sortedQty < data?.pickedQty) || []
+        // Fetch data for both QC and LOADING tabs to ensure banner condition is accurate
+        // If isReleaseGoodScan is true, use release good name; otherwise use binLocationName if QC SKU mode
+        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)
+        ])
+
+        this.qcData = qcData.filter(data => data?.sortedQty < data?.pickedQty) || []
+        this.loadingData =
+          loadingData.filter(data => data?.sortedQty > 0 && data.status != WORKSHEET_STATUS.DONE.value) || []
+
+        // Update QC banner state after data changes
+        if (this._updateQcBannerState) {
+          await this._updateQcBannerState()
+        }
       }
     } catch (e) {
       showToast(e)
@@ -750,11 +1220,8 @@ export class LoadingExecutionBase extends LitElement {
             ._executionData=${loadData}
             @loading=${async e => {
               showToast({ type: 'success', message: 'loaded successfully' })
-              this.loadingData = await this.fetchData(
-                this._currentReleaseGood.releaseGood.name,
-                'loading',
-                this._useQcSku
-              )
+              // Reload all data and counts to update banner and button visibility
+              await this.reload()
             }}
           ></load-by-qty>
         `,
@@ -802,10 +1269,23 @@ export class LoadingExecutionBase extends LitElement {
         // --- Clear previous order and UI data ---
         this._currentReleaseGood = null
         this.loadedData = []
+        this.loadingData = []
+        this.qcData = []
+        this.worksheet = null
+        this.worksheetDetails = null
+        this._tabCounts = null
+        this._hasRefWorksheetId = false
+        this.toteNo = ''
+        this.state = null
 
         setTimeout(async () => {
           try {
-            const orderNo = this._useQcSku ? this.worksheet?.binLocationName : this.worksheet?.releaseGood?.name
+            // If isReleaseGoodScan is true, use release good name; otherwise use binLocationName if QC SKU mode
+            const orderNo = this.worksheet?.isReleaseGoodScan
+              ? this.worksheet?.releaseGood?.name
+              : this._useQcSku
+              ? this.worksheet?.binLocationName
+              : this.worksheet?.releaseGood?.name
             if (!orderNo) {
               resetContext(this.parent)
               return
@@ -817,14 +1297,18 @@ export class LoadingExecutionBase extends LitElement {
                 orderNo,
                 tabName: this.state?.activeTab || TAB_TYPES.LOADING
               },
-              context: gqlContext()
+              context: gqlContext(),
+              fetchPolicy: 'network-only' // Always fetch fresh data to show updated item counts
             })
 
             if (!response.errors) {
               const orders = response.data.findLoadableReleaseGood
-              if (orders.length) {
-                await this.selectReleaseOrderPopup(orders, this.state?.activeTab)
+              // Filter out orders that are already DONE
+              const activeOrders = orders.filter(order => order.status !== 'DONE')
+              if (activeOrders.length) {
+                await this.selectReleaseOrderPopup(activeOrders, this.state?.activeTab)
               } else {
+                // No more active orders, reset to initial scan screen
                 resetContext(this.parent)
               }
             }
@@ -872,10 +1356,23 @@ export class LoadingExecutionBase extends LitElement {
         // --- Clear previous order and UI data ---
         this._currentReleaseGood = null
         this.loadedData = []
+        this.loadingData = []
+        this.qcData = []
+        this.worksheet = null
+        this.worksheetDetails = null
+        this._tabCounts = null
+        this._hasRefWorksheetId = false
+        this.toteNo = ''
+        this.state = null
 
         setTimeout(async () => {
           try {
-            const orderNo = this._useQcSku ? this.worksheet?.binLocationName : this.worksheet?.releaseGood?.name
+            // If isReleaseGoodScan is true, use release good name; otherwise use binLocationName if QC SKU mode
+            const orderNo = this.worksheet?.isReleaseGoodScan
+              ? this.worksheet?.releaseGood?.name
+              : this._useQcSku
+              ? this.worksheet?.binLocationName
+              : this.worksheet?.releaseGood?.name
             if (!orderNo) {
               resetContext(this.parent)
               return
@@ -887,14 +1384,18 @@ export class LoadingExecutionBase extends LitElement {
                 orderNo,
                 tabName: this.state?.activeTab || TAB_TYPES.LOADING
               },
-              context: gqlContext()
+              context: gqlContext(),
+              fetchPolicy: 'network-only' // Always fetch fresh data to show updated item counts
             })
 
             if (!response.errors) {
               const orders = response.data.findLoadableReleaseGood
-              if (orders.length) {
-                await this.selectReleaseOrderPopup(orders, this.state?.activeTab)
+              // Filter out orders that are already DONE
+              const activeOrders = orders.filter(order => order.status !== 'DONE')
+              if (activeOrders.length) {
+                await this.selectReleaseOrderPopup(activeOrders, this.state?.activeTab)
               } else {
+                // No more active orders, reset to initial scan screen
                 resetContext(this.parent)
               }
             }
@@ -934,7 +1435,8 @@ export class LoadingExecutionBase extends LitElement {
 
   async fetchData(orderNo, tab, useQcSku) {
     try {
-      if (tab === 'qc' && useQcSku) {
+      // Otherwise, use FIND_LOADABLE_RELEASE_GOOD_BY_BIN for both QC and LOADING tabs when useQcSku is true (bin scan)
+      if (useQcSku && !this.worksheet?.isReleaseGoodScan) {
         const response = await client.query({
           query: FIND_LOADABLE_RELEASE_GOOD_BY_BIN,
           variables: { orderNo }
@@ -942,6 +1444,10 @@ export class LoadingExecutionBase extends LitElement {
 
         if (!response.errors) {
           const data = response.data.findLoadableReleaseGoodByBin.worksheetDetailInfos
+          // Check if any order inventory has refWorksheetId
+          this._hasRefWorksheetId = data.some(
+            item => item?.relatedOrderInv?.refWorksheetId != null && item?.relatedOrderInv?.refWorksheetId !== ''
+          )
           return combineSameProducts(data)
         }
       } else {
@@ -973,7 +1479,13 @@ export class LoadingExecutionBase extends LitElement {
             worksheetId: worksheetInfo.worksheet.id
           }
 
-          return response.data.loadingWorksheetv2.worksheetDetailInfos
+          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 !== ''
+          )
+
+          return worksheetDetailInfos
         }
       }
     } catch (e) {