feat: 在GcApi中新增获取订单列表功能，并在InspectionDAO中更新订单信息以支持新字段，同时优化加载对话框的订单查询逻辑

apis/gc_api.py

@@ -1,6 +1,9 @@
-from utils.api_utils import ApiUtils
+import requests
-import logging
 import json
+import logging
+from utils.config_loader import ConfigLoader
+from utils.api_utils import ApiUtils
+
 class GcApi:
     """工程API接口类"""
     
@@ -140,3 +143,45 @@ class GcApi:
         except Exception as e:
             logging.error(f"获取包装号失败: {str(e)}")
             return None
+            
+    def get_order_list(self, params):
+        """
+        获取订单列表
+        
+        Args:
+            params: 查询参数字典
+            
+        Returns:
+            dict: 订单列表
+        """
+        try:
+            # API 配置中的键名
+            api_key = "get_order_info"
+            
+            # 构建查询参数
+            order_dict = {
+                "srch_mo": params.get("srch_mo", ""),
+                "srch_note": params.get("srch_note", ""),
+                "srch_rq1": params.get("srch_rq1", ""),
+                "srch_rq2": params.get("srch_rq2", ""),
+                "srch_cz": params.get("srch_cz", ""),
+                "srch_size": params.get("srch_size", ""),
+                "data_corp": params.get("corp_id", "")
+            }
+            
+            # 构建 form-data 格式的数据
+            data = {
+                "parms": json.dumps(order_dict),  # 必须将数据序列化为JSON字符串
+                "pageIndex": 0,
+                "pageSize": 50,  # 获取更多数据
+                "sortField": "create_time",
+                "sortOrder": "desc"
+            }
+            
+            # 调用API
+            response = self.api_utils.post(api_key, data=data)
+            return response
+            
+        except Exception as e:
+            logging.error(f"获取订单列表失败: {str(e)}")
+            return {"status": False, "message": f"获取订单列表失败: {str(e)}"}

dao/inspection_dao.py

@@ -253,7 +253,8 @@ class InspectionDAO:
                             gzl = ?, maxsl = ?, cz = ?, size = ?, cd = ?, luno = ?, 
                             qfqd = ?, pono = ?, xj = ?, ysl = ?, dycz = ?, 
                             zx_code = ?, edit_id = ?, remarks = ?, zx_name = ?,
-                            bccd = ? ,tccd = ?, zzyq = ?, customer = ?,customerexp = ?,bz_bqd = ?,bz_tqd = ?,type_name = ?,remarks_hb=?
+                            bccd = ? ,tccd = ?, zzyq = ?, customer = ?,customerexp = ?,
+                            bz_bqd = ?,bz_tqd = ?,type_name = ?,remarks_hb=?,khno=?
                         WHERE ddmo = ?
                     """
                     params = (
@@ -295,6 +296,7 @@ class InspectionDAO:
                         data.get("bz_tqd", ""),
                         data.get("type_name", ""),
                         data.get("remarks_hb", ""),
+                        data.get("khno", ""),
                         data.get("mo", "")  # WHERE 条件参数
                     )
                     logging.info(f"更新订单信息: ddmo={data.get('mo', '')}")
@@ -305,10 +307,12 @@ class InspectionDAO:
                             data_corp, user_id, user_name, gzl_zl, ddmo, xpack, 
                             qd, spack_type, mxzs, jt, ddnote, code, type, 
                             lable, lib, gzl, maxsl, cz, size, cd, luno, qfqd, 
-                            pono, xj, ysl, dycz, zx_code, edit_id, remarks,zx_name,bccd,tccd,zzyq,customer,customerexp,bz_bqd,bz_tqd,type_name,remarks_hb
+                            pono, xj, ysl, dycz, zx_code, edit_id, remarks,zx_name,
+                            bccd,tccd,zzyq,customer,customerexp,bz_bqd,bz_tqd,type_name,
+                            remarks_hb,khno
                         ) VALUES (
                             ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 
-                            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+                            ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
                         )
                     """
                     params = (
@@ -350,7 +354,8 @@ class InspectionDAO:
                         data.get("bz_bqd", ""),
                         data.get("bz_tqd", ""),
                         data.get("type_name", ""),
-                        data.get("remarks_hb", "")
+                        data.get("remarks_hb", ""),
+                        data.get("khno", "")
                     )
                     logging.info(f"插入新订单信息: ddmo={data.get('mo', '')}")
             

tests/test_gc_api.py

@@ -1,48 +0,0 @@
-import sys
-import os
-import logging
-from pathlib import Path
-
-# 添加项目根目录到系统路径，以便导入模块
-project_root = str(Path(__file__).parent.parent)
-sys.path.insert(0, project_root)
-
-# 配置日志
-logging.basicConfig(level=logging.INFO, 
-                   format='%(asctime)s - %(levelname)s - %(name)s - [%(funcName)s:%(lineno)d] - %(message)s')
-
-# 导入需要测试的模块
-from apis.gc_api import GcApi
-
-def test_gc_api():
-    """测试 GcApi 的 get_gc_info 方法是否能正确处理 form-data 格式的请求"""
-    print("开始测试 GcApi.get_gc_info 方法...")
-    
-    # 创建 GcApi 实例
-    gc_api = GcApi()
-    
-    # 测试工程号
-    test_gc_code = "JTPD25060003"
-    
-    # 调用方法
-    print(f"使用工程号 {test_gc_code} 调用 get_gc_info...")
-    response = gc_api.get_gc_info(test_gc_code)
-    
-    # 打印结果
-    print(f"API 响应: {response}")
-    
-    if response:
-        print("测试成功: API 返回了有效响应")
-    else:
-        print("测试失败: API 返回了空响应")
-    
-    # 检查响应格式
-    if isinstance(response, dict) and "status" in response:
-        print(f"响应状态: {response.get('status', False)}")
-        print(f"响应消息: {response.get('message', '')}")
-        print(f"响应数据: {response.get('data', None)}")
-    else:
-        print(f"响应格式不符合预期: {response}")
-
-if __name__ == "__main__":
-    test_gc_api() 

ui/loading_dialog_ui.py

@@ -92,13 +92,44 @@ class LoadingDialogUI(QDialog):
         self.order_label.setFixedWidth(100)
         self.order_label.setFixedHeight(45)
         
+        # 创建一个水平布局，包含输入框和查询按钮
+        order_input_layout = QHBoxLayout()
+        order_input_layout.setSpacing(0)
+        order_input_layout.setContentsMargins(0, 0, 0, 0)
+        
         self.order_input = QLineEdit()
         self.order_input.setFont(self.normal_font)
         self.order_input.setPlaceholderText("请扫描订单号")
         self.order_input.setStyleSheet(input_style)
         self.order_input.setFixedHeight(45)
+        
+        # 添加查询按钮
+        self.order_query_btn = QPushButton("...")
+        self.order_query_btn.setFont(self.normal_font)
+        self.order_query_btn.setFixedSize(45, 45)
+        self.order_query_btn.setStyleSheet("""
+            QPushButton {
+                border: none;
+                border-right: 1px solid #e0e0e0;
+                border-bottom: 1px solid #e0e0e0;
+                background-color: #f5f5f5;
+                color: #333333;
+                font-weight: bold;
+            }
+            QPushButton:hover {
+                background-color: #e0e0e0;
+            }
+            QPushButton:pressed {
+                background-color: #d0d0d0;
+            }
+        """)
+        
+        # 添加到水平布局
+        order_input_layout.addWidget(self.order_input)
+        order_input_layout.addWidget(self.order_query_btn)
+        
         row1.addWidget(self.order_label)
-        row1.addWidget(self.order_input, 1)
+        row1.addLayout(order_input_layout, 1)
         container_layout.addLayout(row1)
 
         # 添加水平分隔布局

ui/order_query_dialog_ui.py

@@ -0,0 +1,355 @@
+from PySide6.QtWidgets import (
+    QDialog, QLabel, QLineEdit, QComboBox, QPushButton,
+    QVBoxLayout, QHBoxLayout, QFrame, QTableWidget, QTableWidgetItem,
+    QHeaderView, QDateEdit, QApplication
+)
+from PySide6.QtCore import Qt, QDate
+from PySide6.QtGui import QFont
+
+class OrderQueryDialogUI(QDialog):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("订单查询")
+        self.resize(1400, 700)  # 增加宽度和高度
+        
+        # 设置字体
+        self.normal_font = QFont("微软雅黑", 10)
+        self.title_font = QFont("微软雅黑", 10, QFont.Bold)
+        
+        # 初始化UI
+        self.init_ui()
+    
+    def init_ui(self):
+        """初始化UI"""
+        # 主布局
+        self.main_layout = QVBoxLayout(self)
+        self.main_layout.setContentsMargins(20, 20, 20, 20)
+        self.main_layout.setSpacing(10)
+        
+        # 创建查询条件区域
+        self.create_query_frame()
+        
+        # 创建结果表格
+        self.create_result_table()
+        
+        # 创建按钮
+        self.create_buttons()
+    
+    def create_query_frame(self):
+        """创建查询条件区域"""
+        # 创建一个带边框的容器
+        query_frame = QFrame()
+        query_frame.setStyleSheet("""
+            QFrame {
+                border: 1px solid #e0e0e0;
+                background-color: white;
+                border-radius: 4px;
+            }
+        """)
+        
+        # 容器的垂直布局
+        query_layout = QVBoxLayout(query_frame)
+        query_layout.setContentsMargins(15, 15, 15, 15)
+        query_layout.setSpacing(10)
+        
+        # 第一行：日期范围和订单Mo
+        row1 = QHBoxLayout()
+        
+        # 日期标签
+        date_label = QLabel("日期:")
+        date_label.setFont(self.normal_font)
+        date_label.setFixedWidth(40)
+        
+        # 开始日期
+        self.start_date = QDateEdit()
+        self.start_date.setFont(self.normal_font)
+        self.start_date.setCalendarPopup(True)
+        self.start_date.setDate(QDate.currentDate().addDays(-7))
+        self.start_date.setFixedWidth(120)
+        self.start_date.setStyleSheet("""
+            QDateEdit {
+                border: 1px solid #e0e0e0;
+                padding: 4px;
+                border-radius: 4px;
+            }
+        """)
+        
+        # 至标签
+        to_label = QLabel("至:")
+        to_label.setFont(self.normal_font)
+        to_label.setFixedWidth(20)
+        
+        # 结束日期
+        self.end_date = QDateEdit()
+        self.end_date.setFont(self.normal_font)
+        self.end_date.setCalendarPopup(True)
+        self.end_date.setDate(QDate.currentDate())
+        self.end_date.setFixedWidth(120)
+        self.end_date.setStyleSheet("""
+            QDateEdit {
+                border: 1px solid #e0e0e0;
+                padding: 4px;
+                border-radius: 4px;
+            }
+        """)
+        
+        # 订单Mo标签
+        order_mo_label = QLabel("订单Mo:")
+        order_mo_label.setFont(self.normal_font)
+        order_mo_label.setFixedWidth(60)
+        
+        # 订单Mo输入框
+        self.order_mo_input = QLineEdit()
+        self.order_mo_input.setFont(self.normal_font)
+        self.order_mo_input.setStyleSheet("""
+            QLineEdit {
+                border: 1px solid #e0e0e0;
+                padding: 4px;
+                border-radius: 4px;
+            }
+            QLineEdit:focus {
+                border: 1px solid #66afe9;
+            }
+        """)
+        
+        # 材质标签
+        material_label = QLabel("材质")
+        material_label.setFont(self.normal_font)
+        material_label.setFixedWidth(40)
+        
+        # 材质下拉框
+        self.material_combo = QComboBox()
+        self.material_combo.setFont(self.normal_font)
+        self.material_combo.addItem("全部")
+        self.material_combo.setStyleSheet("""
+            QComboBox {
+                border: 1px solid #e0e0e0;
+                padding: 4px;
+                border-radius: 4px;
+            }
+            QComboBox::drop-down {
+                subcontrol-origin: padding;
+                subcontrol-position: top right;
+                width: 20px;
+                border-left: 1px solid #e0e0e0;
+            }
+        """)
+        
+        # 规格标签
+        spec_label = QLabel("规格")
+        spec_label.setFont(self.normal_font)
+        spec_label.setFixedWidth(40)
+        
+        # 规格输入框
+        self.spec_input = QLineEdit()
+        self.spec_input.setFont(self.normal_font)
+        self.spec_input.setStyleSheet("""
+            QLineEdit {
+                border: 1px solid #e0e0e0;
+                padding: 4px;
+                border-radius: 4px;
+            }
+            QLineEdit:focus {
+                border: 1px solid #66afe9;
+            }
+        """)
+        
+        # 查询按钮
+        self.query_button = QPushButton("查询")
+        self.query_button.setFont(self.normal_font)
+        self.query_button.setStyleSheet("""
+            QPushButton {
+                background-color: #0078d4;
+                color: white;
+                border: none;
+                border-radius: 4px;
+                padding: 6px 16px;
+            }
+            QPushButton:hover {
+                background-color: #106ebe;
+            }
+            QPushButton:pressed {
+                background-color: #005a9e;
+            }
+        """)
+        self.query_button.setFixedWidth(80)
+        
+        # 添加组件到第一行布局
+        row1.addWidget(date_label)
+        row1.addWidget(self.start_date)
+        row1.addWidget(to_label)
+        row1.addWidget(self.end_date)
+        row1.addSpacing(20)
+        row1.addWidget(order_mo_label)
+        row1.addWidget(self.order_mo_input, 1)
+        row1.addSpacing(20)
+        row1.addWidget(material_label)
+        row1.addWidget(self.material_combo, 1)
+        row1.addSpacing(20)
+        row1.addWidget(spec_label)
+        row1.addWidget(self.spec_input, 1)
+        row1.addSpacing(20)
+        row1.addWidget(self.query_button)
+        
+        # 添加第一行到查询布局
+        query_layout.addLayout(row1)
+        
+        # 将查询框架添加到主布局
+        self.main_layout.addWidget(query_frame)
+    
+    def create_result_table(self):
+        """创建结果表格"""
+        # 创建表格
+        self.result_table = QTableWidget()
+        self.result_table.setFont(self.normal_font)
+        
+        # 设置表头样式
+        header = self.result_table.horizontalHeader()
+        header.setStyleSheet("""
+            QHeaderView::section {
+                background-color: #f5f5f5;
+                color: #333333;
+                padding: 5px;
+                border: 1px solid #e0e0e0;
+                font-weight: bold;
+            }
+        """)
+        
+        # 设置表格样式
+        self.result_table.setStyleSheet("""
+            QTableWidget {
+                border: 1px solid #e0e0e0;
+                gridline-color: #e0e0e0;
+                selection-background-color: #0078d4;
+                selection-color: white;
+            }
+            QTableWidget::item {
+                padding: 5px;
+                border-bottom: 1px solid #e0e0e0;
+            }
+        """)
+        
+        # 启用水平滚动条
+        self.result_table.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+        
+        # 设置表头自适应宽度
+        header.setSectionResizeMode(QHeaderView.Interactive)
+        
+        # 设置默认列宽 - 常用列宽一些，不常用列窄一些
+        self.result_table.setColumnWidth(0, 60)   # 序号
+        self.result_table.setColumnWidth(1, 100)  # 日期
+        self.result_table.setColumnWidth(2, 120)  # 订单号
+        self.result_table.setColumnWidth(3, 120)  # 订单明细
+        self.result_table.setColumnWidth(4, 120)  # 客户
+        self.result_table.setColumnWidth(5, 120)  # 客户实际订单号
+        self.result_table.setColumnWidth(6, 100)  # 订单类别
+        self.result_table.setColumnWidth(7, 100)  # 客户交期
+        self.result_table.setColumnWidth(8, 100)  # 编码
+        self.result_table.setColumnWidth(9, 100)  # 产品类别
+        self.result_table.setColumnWidth(10, 80)  # 材质
+        self.result_table.setColumnWidth(11, 80)  # 规格
+        self.result_table.setColumnWidth(12, 80)  # 产地
+        self.result_table.setColumnWidth(13, 80)  # 最大入库量
+        self.result_table.setColumnWidth(14, 100) # 托盘号
+        self.result_table.setColumnWidth(15, 100) # 轴型
+        self.result_table.setColumnWidth(16, 80)  # 轴型code
+        self.result_table.setColumnWidth(17, 80)  # 轴型重量
+        
+        # 其他列使用默认宽度
+        
+        # 设置表格可以选择整行
+        self.result_table.setSelectionBehavior(QTableWidget.SelectRows)
+        
+        # 设置表格只能单选
+        self.result_table.setSelectionMode(QTableWidget.SingleSelection)
+        
+        # 添加表格到主布局
+        self.main_layout.addWidget(self.result_table, 1)  # 1表示拉伸因子，让表格占据更多空间
+    
+    def create_buttons(self):
+        """创建底部按钮"""
+        button_layout = QHBoxLayout()
+        
+        # 分页控件（示例）
+        page_layout = QHBoxLayout()
+        
+        # 添加分页按钮（示例）
+        self.first_page_btn = QPushButton("<<")
+        self.prev_page_btn = QPushButton("<")
+        self.page_label = QLabel("1 / 1")
+        self.next_page_btn = QPushButton(">")
+        self.last_page_btn = QPushButton(">>")
+        
+        page_style = """
+            QPushButton {
+                border: 1px solid #e0e0e0;
+                background-color: white;
+                padding: 4px 8px;
+            }
+            QPushButton:hover {
+                background-color: #f5f5f5;
+            }
+            QLabel {
+                padding: 0 10px;
+            }
+        """
+        
+        self.first_page_btn.setStyleSheet(page_style)
+        self.prev_page_btn.setStyleSheet(page_style)
+        self.next_page_btn.setStyleSheet(page_style)
+        self.last_page_btn.setStyleSheet(page_style)
+        
+        page_layout.addWidget(self.first_page_btn)
+        page_layout.addWidget(self.prev_page_btn)
+        page_layout.addWidget(self.page_label)
+        page_layout.addWidget(self.next_page_btn)
+        page_layout.addWidget(self.last_page_btn)
+        
+        # 确认和取消按钮
+        self.confirm_button = QPushButton("确认")
+        self.confirm_button.setFont(self.normal_font)
+        self.confirm_button.setStyleSheet("""
+            QPushButton {
+                background-color: #0078d4;
+                color: white;
+                border: none;
+                border-radius: 4px;
+                padding: 8px 16px;
+            }
+            QPushButton:hover {
+                background-color: #106ebe;
+            }
+            QPushButton:pressed {
+                background-color: #005a9e;
+            }
+        """)
+        self.confirm_button.setFixedSize(100, 35)
+        
+        self.cancel_button = QPushButton("取消")
+        self.cancel_button.setFont(self.normal_font)
+        self.cancel_button.setStyleSheet("""
+            QPushButton {
+                background-color: white;
+                color: #333333;
+                border: 1px solid #e0e0e0;
+                border-radius: 4px;
+                padding: 8px 16px;
+            }
+            QPushButton:hover {
+                background-color: #f5f5f5;
+            }
+            QPushButton:pressed {
+                background-color: #e0e0e0;
+            }
+        """)
+        self.cancel_button.setFixedSize(100, 35)
+        
+        # 添加分页控件和按钮到布局
+        button_layout.addLayout(page_layout)
+        button_layout.addStretch()
+        button_layout.addWidget(self.confirm_button)
+        button_layout.addSpacing(20)
+        button_layout.addWidget(self.cancel_button)
+        
+        # 添加按钮布局到主布局
+        self.main_layout.addLayout(button_layout) 

widgets/loading_dialog_widget.py

@@ -1,25 +1,30 @@
-from ui.loading_dialog_ui import LoadingDialogUI
-from apis.tary_api import TaryApi
-from PySide6.QtCore import Qt, Signal
-from PySide6.QtWidgets import QMessageBox, QDialog
 import logging
+from PySide6.QtWidgets import QMessageBox
+from PySide6.QtCore import Qt, Signal
+from ui.loading_dialog_ui import LoadingDialogUI
+from widgets.order_query_dialog import OrderQueryDialog
 from utils.app_mode import AppMode
 from utils.pallet_type_manager import PalletTypeManager
 from apis.gc_api import GcApi
-class LoadingDialog(LoadingDialogUI):
 
-    # 定义一个信号，用于向主窗口传递托盘号
+class LoadingDialog(LoadingDialogUI):
+    """上料操作对话框"""
+    
+    # 定义信号，用于向主窗口传递托盘号
     tray_code_signal = Signal(str, str, str, str)
-    # 定义一个信号，用于向主窗口传递订单号
+    # 定义信号，用于向主窗口传递订单号
     order_code_signal = Signal(str)
     
     def __init__(self, parent=None, user_id=None, user_name=None, corp_id=None):
-        """初始化加载对话框"""
         super().__init__()
         self.parent = parent
         self.user_id = user_id
         self.user_name = user_name
         self.corp_id = corp_id
+        
+        # 存储订单数据
+        self.order_data = None
+        
         # 彻底禁用对话框的回车键关闭功能
         self.setModal(True)
         # 禁用所有按钮的默认行为
@@ -35,11 +40,14 @@ class LoadingDialog(LoadingDialogUI):
         from utils.focus_tracker import FocusTracker
         self.focus_tracker = FocusTracker.get_instance()
         
-        # 绑定事件
+        # 连接信号和槽
-        self.setup_connections()
+        self.connect_signals()
+    
+    def connect_signals(self):
+        """连接信号和槽"""
+        # 订单查询按钮点击事件
+        self.order_query_btn.clicked.connect(self.show_order_query_dialog)
         
-    def setup_connections(self):
-        """设置事件连接"""
         # 订单号输入框回车事件触发查询
         self.order_input.returnPressed.connect(self.handle_order_return_pressed)
         
@@ -48,6 +56,10 @@ class LoadingDialog(LoadingDialogUI):
         
         # 取消按钮点击事件
         self.cancel_button.clicked.connect(self.reject)
+        
+        # 托盘号输入框回车事件
+        self.tray_input.returnPressed.connect(self.on_tray_entered)
+    
     def handle_order_return_pressed(self):
         """处理订单输入框的回车事件"""
         logging.info("订单输入框回车事件触发")
@@ -64,25 +76,109 @@ class LoadingDialog(LoadingDialogUI):
             logging.info(f"发送订单号到主窗口: {order_code}")
             self.order_code_signal.emit(order_code)
         
-        #判断是否是接口，如果不是接口直接添加如果是则走接口
+        # 查询订单信息
-        # 如果开启接口模式，则需要调用接口同步到业务库
-        order_info = None
         self.on_order_query(order_code)
         
         # 阻止事件继续传播
         return True
     
+    def show_order_query_dialog(self):
+        """显示订单查询对话框"""
+        try:
+            # 创建订单查询对话框
+            dialog = OrderQueryDialog(self)
+            
+            # 连接订单选择信号
+            dialog.order_selected.connect(self.on_order_selected)
+            
+            # 显示对话框
+            dialog.exec()
+            
+        except Exception as e:
+            logging.error(f"显示订单查询对话框失败: {e}")
+            QMessageBox.critical(self, "错误", f"显示订单查询对话框失败: {str(e)}")
+    
+    def on_order_selected(self, order_data):
+        """处理订单选择事件
+        
+        Args:
+            order_data: 订单数据字典
+        """
+        try:
+            # 存储订单数据
+            self.order_data = order_data
+            
+            # 更新UI
+            # 注意：此时order_data["note"]已经被修改为order_data["mo"]的值
+            self.order_input.setText(order_data.get("note", ""))
+            
+            # 更新轴型
+            self.axis_value.setText(order_data.get("zx_name", "--"))
+            
+            # 更新数量
+            self.quantity_value.setText(str(order_data.get("sl", "--")))
+            
+            # 更新重量
+            self.weight_value.setText(str(order_data.get("zx_zl", "--")))
+            
+            # 发送订单号到主窗口
+            from widgets.main_window import MainWindow
+            main_window = self.parent
+            if main_window and isinstance(main_window, MainWindow):
+                # 使用note字段作为订单号（已经被修改为mo的值）
+                order_code = order_data.get("note", "")
+                logging.info(f"发送订单号到主窗口: {order_code}")
+                self.order_code_signal.emit(order_code)
+            
+            # 设置焦点到托盘号输入框
+            self.tray_input.setFocus()
+            
+        except Exception as e:
+            logging.error(f"处理订单选择事件失败: {e}")
+            QMessageBox.critical(self, "错误", f"处理订单选择事件失败: {str(e)}")
+    
     def on_order_query(self, order_code):
         """查询订单信息，同时生成托盘号，并且回显到页面上"""
         try:
-            if AppMode.is_api():
+            # 构建查询参数
+            query_params = {
+                "srch_mo": order_code,
+                "srch_note": order_code,
+                "corp_id": self.corp_id
+            }
+            
+            # 创建订单查询对话框（仅用于执行查询）
+            dialog = OrderQueryDialog(self)
+            
+            # 执行查询
+            results = dialog.query_orders(query_params)
+            
+            # 处理查询结果
+            if results:
+                # 如果只有一个结果，直接使用
+                if len(results) == 1:
+                    self.on_order_selected(results[0])
+                    return
+                else:
+                    # 如果有多个结果，显示查询对话框让用户选择
+                    dialog.update_result_table(results)
+                    dialog.order_selected.connect(self.on_order_selected)
+                    dialog.exec()
+                    return
+            
+            # 如果没有结果，并且不是API模式，显示提示
+            if not AppMode.is_api():
+                QMessageBox.warning(self, "提示", f"未找到订单: {order_code}")
+                return
+                
+            # 如果是API模式，尝试使用旧的API方式查询
             # 调用接口
             gc_api = GcApi()
             # 防止response为None导致异常
             # 获取工程号信息，并且初始化数据
             order_response = gc_api.get_order_info(order_code, self.corp_id)
             # 生成托盘号
-                if(order_response.get("status",False)):
+            if order_response and order_response.get("status", False):
                 # 将接口数据保存到数据库，用于后续的关联使用
                 from dao.inspection_dao import InspectionDAO
                 inspection_dao = InspectionDAO()
@@ -94,13 +190,21 @@ class LoadingDialog(LoadingDialogUI):
                 inspection_dao.save_order_info(order_code, order_info)
                 self.axis_value.setText(order_info['zx_name'])
                 self.quantity_value.setText(str(order_info['sl']))
-                    self.weight_value.setText(str(order_info['sl']))
+                self.weight_value.setText(str(order_info['zx_zl']))
+                
+                # 存储订单数据
+                self.order_data = order_info
+            else:
+                QMessageBox.warning(self, "提示", f"未找到订单: {order_code}")
+                return
+            
             xpack_response = gc_api.get_xpack(order_code, self.corp_id)
-                if(xpack_response.get("status",False)):
+            if xpack_response and xpack_response.get("status", False):
                 xpack = xpack_response['xpack']
                 self.tray_input.setText(xpack)
                 self.pallet_tier_value.setText('3')
-            # 发送托盘号到主窗
+            
+                # 发送托盘号到主窗口
                 from widgets.main_window import MainWindow
                 main_window = self.parent
                 if main_window and isinstance(main_window, MainWindow):
@@ -121,9 +225,20 @@ class LoadingDialog(LoadingDialogUI):
                     logging.info(f"设置主窗口当前托盘号: {xpack}")
             
             return order_info
+                
         except Exception as e:
-            logging.error(f"查询订单信息异常: {str(e)}")
+            logging.error(f"查询订单信息失败: {e}")
-            return None
+            QMessageBox.critical(self, "错误", f"查询订单信息失败: {str(e)}")
+    
+    def on_tray_entered(self):
+        """处理托盘号输入框回车事件"""
+        tray_id = self.tray_input.text().strip()
+        if not tray_id:
+            QMessageBox.warning(self, "提示", "请输入托盘号")
+            return
+        
+        # 设置焦点到托盘料输入框
+        self.pallet_tier_value.setFocus()
     
     def keyPressEvent(self, event):
         """重写键盘事件处理，防止回车关闭对话框"""
@@ -132,9 +247,7 @@ class LoadingDialog(LoadingDialogUI):
             logging.info(f"捕获到回车键事件，当前焦点部件: {self.focusWidget()}")
             
             # 如果焦点在托盘输入框上，触发查询
-            # 注释掉此处的on_tray_query调用，因为已经通过returnPressed信号处理了
             if self.focusWidget() == self.tray_input:
-                # self.on_tray_query() - 通过returnPressed信号已经处理，这里不需要再调用
                 event.accept()  # 消费掉这个事件
                 return
             
@@ -165,9 +278,19 @@ class LoadingDialog(LoadingDialogUI):
             QMessageBox.warning(self, "提示", "请输入托盘号")
             return
         
+        # 检查订单号
+        order_id = self.order_input.text().strip()
+        if not order_id:
+            QMessageBox.warning(self, "提示", "请输入订单号")
+            self.order_input.setFocus()
+            return
+        
+        if not self.order_data:
+            QMessageBox.warning(self, "提示", "请先查询订单信息")
+            return
+        
         try:
             # 保存托盘档案信息
-            from utils.pallet_type_manager import PalletTypeManager
             pallet_manager = PalletTypeManager.get_instance()
             success = pallet_manager.save_pallet_archives(
                 pallet_code=pallet_code,
@@ -213,3 +336,16 @@ class LoadingDialog(LoadingDialogUI):
         logging.info("取消按钮被点击或ESC触发取消")
         # 调用父类的reject方法关闭对话框
         super().reject()
+    
+    def get_loading_data(self):
+        """获取上料数据
+        
+        Returns:
+            dict: 上料数据字典
+        """
+        return {
+            "order_id": self.order_input.text().strip(),
+            "tray_id": self.tray_input.text().strip(),
+            "pallet_tier": self.pallet_tier_value.text().strip(),
+            "order_data": self.order_data
+        } 

widgets/main_window.py

@@ -2002,6 +2002,10 @@ class MainWindow(MainWindowUI):
                 info.update(order_others_info)
                 info['data_corp'] = order_info['data_corp']
                 info['zh'] = axios_num
+                info['mzl'] = weight_kg
+                info['printsl'] = 1
+                info['pono'] = self._current_order_code
+                info["dycz"] = info.get("cz")
                 # 获取本机IP地址
                 # import socket
                 # try:

widgets/order_query_dialog.py

@@ -0,0 +1,455 @@
+import logging
+from datetime import datetime
+from PySide6.QtWidgets import QTableWidgetItem, QMessageBox
+from PySide6.QtCore import Qt, Signal
+from ui.order_query_dialog_ui import OrderQueryDialogUI
+from utils.sql_utils import SQLUtils
+from utils.app_mode import AppMode
+from apis.gc_api import GcApi
+
+class OrderQueryDialog(OrderQueryDialogUI):
+    """订单查询对话框，用于查询订单信息"""
+    
+    # 定义信号，用于向上传递选中的订单信息
+    order_selected = Signal(dict)
+    
+    def __init__(self, parent=None):
+        super().__init__()
+        
+        # 存储查询结果
+        self.query_results = []
+        
+        # 获取父窗口的用户信息
+        self.corp_id = None
+        self.user_id = None
+        self.user_name = None
+        if parent:
+            if hasattr(parent, 'corp_id'):
+                self.corp_id = parent.corp_id
+            if hasattr(parent, 'user_id'):
+                self.user_id = parent.user_id
+            if hasattr(parent, 'user_name'):
+                self.user_name = parent.user_name
+        
+        # 连接信号和槽
+        self.connect_signals()
+    
+    def connect_signals(self):
+        """连接信号和槽"""
+        # 查询按钮点击事件
+        self.query_button.clicked.connect(self.on_order_query)
+        
+        # 确认按钮点击事件
+        self.confirm_button.clicked.connect(self.on_confirm)
+        
+        # 取消按钮点击事件
+        self.cancel_button.clicked.connect(self.reject)
+        
+        # 表格双击事件
+        self.result_table.cellDoubleClicked.connect(self.on_table_double_clicked)
+    
+    def on_order_query(self):
+        """执行订单查询"""
+        try:
+            # 获取查询参数
+            start_date = self.start_date.date().toString("yyyy-MM-dd")
+            end_date = self.end_date.date().toString("yyyy-MM-dd")
+            order_mo = self.order_mo_input.text().strip()
+            material = self.material_combo.currentText()
+            if material == "全部":
+                material = ""
+            spec = self.spec_input.text().strip()
+            
+            # 构建查询参数
+            query_params = {
+                "srch_rq1": start_date,
+                "srch_rq2": end_date,
+                "srch_mo": order_mo,
+                "srch_note": order_mo,
+                "srch_cz": material,
+                "srch_size": spec,
+                "corp_id": self.corp_id
+            }
+            
+            # 执行查询
+            results = self.query_orders(query_params)
+            
+            # 更新表格
+            self.update_result_table(results)
+            
+        except Exception as e:
+            logging.error(f"订单查询失败: {e}")
+            QMessageBox.critical(self, "查询错误", f"查询订单时发生错误: {str(e)}")
+    
+    def query_orders(self, params):
+        """查询订单数据
+        
+        Args:
+            params: 查询参数字典
+            
+        Returns:
+            list: 订单数据列表
+        """
+        try:
+            # 如果是API模式，优先从接口获取数据
+            if AppMode.is_api():
+                return self._query_orders_from_api(params)
+            else:
+                return self._query_orders_from_db(params)
+                
+        except Exception as e:
+            logging.error(f"查询订单数据失败: {e}")
+            raise
+    
+    def _query_orders_from_api(self, params):
+        """从API获取订单数据
+        
+        Args:
+            params: 查询参数字典
+            
+        Returns:
+            list: 订单数据列表
+        """
+        try:
+            # 调用接口
+            gc_api = GcApi()
+            
+            # 调用接口查询订单列表
+            response = gc_api.get_order_list(params)
+            
+            # 处理接口返回结果
+            if response and response.get("status", False):
+                # 将接口返回的数据转换为标准格式
+                orders_data = response.get("data", [])
+                results = []
+                
+                for order_data in orders_data:
+                    # 转换为统一格式的字典
+                    order_dict = {
+                        "note": order_data.get("note", ""),
+                        "mo": order_data.get("mo", ""),
+                        "customer": order_data.get("customer", ""),
+                        "khno": order_data.get("khno", ""),
+                        "ddzl": order_data.get("ddzl", ""),
+                        "khjq": order_data.get("khjq", ""),
+                        "code": order_data.get("code", ""),
+                        "type": order_data.get("type", ""),
+                        "cz": order_data.get("cz", ""),
+                        "size": order_data.get("size", ""),
+                        "cd": order_data.get("cd", ""),
+                        "maxsl": order_data.get("maxsl", ""),
+                        "spack": order_data.get("spack", ""),
+                        "zx_name": order_data.get("zx_name", ""),
+                        "zx_code": order_data.get("zx_code", ""),
+                        "zx_zl": order_data.get("zx_zl", ""),
+                        "template_name": order_data.get("template_name", ""),
+                        "bqlb": order_data.get("bqlb", ""),
+                        # 删除重复的khno字段
+                        "dycz": order_data.get("dycz", ""),
+                        "luno": order_data.get("luno", ""),
+                        "corp": order_data.get("corp", ""),
+                        "sl": order_data.get("sl", ""),
+                        "tccd": order_data.get("tccd", ""),
+                        "bccd": order_data.get("bccd", ""),
+                        "ysl": order_data.get("ysl", ""),
+                        "qfqd": order_data.get("qfqd", ""),
+                        "yzgg": order_data.get("yzgg", ""),
+                        "tqd": order_data.get("tqd", ""),
+                        "bqd": order_data.get("bqd", ""),
+                        "bzfs": order_data.get("bzfs", ""),
+                        "ddyq": order_data.get("ddyq", ""),
+                        "remarks_hb": order_data.get("remarks_hb", ""),
+                        "bz_tqd": order_data.get("bz_tqd", ""),
+                        "bz_bqd": order_data.get("bz_bqd", ""),
+                        "zzyq": order_data.get("zzyq", ""),
+                        "rq": order_data.get("rq", "")
+                    }
+                    results.append(order_dict)
+                
+                # 保存查询结果
+                self.query_results = results
+                
+                # 如果接口查询到数据，则保存到数据库中
+                if results:
+                    self._save_orders_to_db(results)
+                
+                return results
+            else:
+                # 如果接口查询失败，则尝试从数据库查询
+                logging.warning("从API获取订单数据失败，尝试从数据库查询")
+                return self._query_orders_from_db(params)
+                
+        except Exception as e:
+            logging.error(f"从API获取订单数据失败: {e}")
+            # 如果接口查询失败，则尝试从数据库查询
+            logging.warning("从API获取订单数据失败，尝试从数据库查询")
+            return self._query_orders_from_db(params)
+    
+    def _save_orders_to_db(self, orders):
+        """将订单数据保存到数据库
+        
+        Args:
+            orders: 订单数据列表
+        """
+        try:
+            # 导入DAO
+            from dao.inspection_dao import InspectionDAO
+            inspection_dao = InspectionDAO()
+            
+            # 遍历订单数据，保存到数据库
+            for order_data in orders:
+                order_code = order_data.get("note", "")
+                if order_code:
+                    # 设置用户信息
+                    if self.user_id:
+                        order_data['user_id'] = self.user_id
+                    if self.user_name:
+                        order_data['user_name'] = self.user_name
+                    if self.corp_id:
+                        order_data['data_corp'] = self.corp_id
+                    
+                    # 保存订单信息
+                    inspection_dao.save_order_info(order_code, order_data)
+            
+            logging.info(f"成功保存{len(orders)}条订单数据到数据库")
+            
+        except Exception as e:
+            logging.error(f"保存订单数据到数据库失败: {e}")
+    
+    def _query_orders_from_db(self, params):
+        """从数据库获取订单数据
+        
+        Args:
+            params: 查询参数字典
+            
+        Returns:
+            list: 订单数据列表
+        """
+        # 构建SQL查询
+        sql = """
+        SELECT 
+            o.note, o.mo, o.customer, o.khno, o.ddzl, o.khjq, o.code, o.type,
+            o.cz, o.size, o.cd, o.maxsl, o.spack, o.zx_name, o.zx_code, o.zx_zl,
+            o.template_name, o.bqlb, o.dycz, o.luno, o.corp, o.sl, o.tccd, o.bccd,
+            o.ysl, o.qfqd, o.yzgg, o.tqd, o.bqd, o.bzfs, o.ddyq, o.remarks_hb,
+            o.bz_tqd, o.bz_bqd, o.zzyq, o.create_time as rq
+        FROM wsbz_order_info o
+        WHERE 1=1
+        """
+        
+        query_params = []
+        
+        # 添加查询条件
+        if params.get("srch_rq1") and params.get("srch_rq2"):
+            sql += " AND o.create_time BETWEEN ? AND ?"
+            query_params.append(params["srch_rq1"] + " 00:00:00")
+            query_params.append(params["srch_rq2"] + " 23:59:59")
+        
+        if params.get("srch_mo"):
+            sql += " AND (o.mo LIKE ? OR o.note LIKE ?)"
+            query_params.append(f"%{params['srch_mo']}%")
+            query_params.append(f"%{params['srch_mo']}%")
+        
+        if params.get("srch_cz"):
+            sql += " AND o.cz = ?"
+            query_params.append(params["srch_cz"])
+        
+        if params.get("srch_size"):
+            sql += " AND o.size LIKE ?"
+            query_params.append(f"%{params['srch_size']}%")
+        
+        # 添加排序
+        sql += " ORDER BY o.create_time DESC"
+        
+        # 执行查询
+        with SQLUtils('sqlite') as db:
+            db.execute_query(sql, query_params)
+            rows = db.fetchall()
+        
+        # 处理查询结果
+        results = []
+        for row in rows:
+            # 将元组转换为字典
+            order_data = {
+                "note": row[0],
+                "mo": row[1],
+                "customer": row[2],
+                "khno": row[3],
+                "ddzl": row[4],
+                "khjq": row[5],
+                "code": row[6],
+                "type": row[7],
+                "cz": row[8],
+                "size": row[9],
+                "cd": row[10],
+                "maxsl": row[11],
+                "spack": row[12],
+                "zx_name": row[13],
+                "zx_code": row[14],
+                "zx_zl": row[15],
+                "template_name": row[16],
+                "bqlb": row[17],
+                "dycz": row[18],
+                "luno": row[19],
+                "corp": row[20],
+                "sl": row[21],
+                "tccd": row[22],
+                "bccd": row[23],
+                "ysl": row[24],
+                "qfqd": row[25],
+                "yzgg": row[26],
+                "tqd": row[27],
+                "bqd": row[28],
+                "bzfs": row[29],
+                "ddyq": row[30],
+                "remarks_hb": row[31],
+                "bz_tqd": row[32],
+                "bz_bqd": row[33],
+                "zzyq": row[34],
+                "rq": row[35]
+            }
+            results.append(order_data)
+        
+        # 保存查询结果
+        self.query_results = results
+        
+        return results
+    
+    def update_result_table(self, results):
+        """更新结果表格
+        
+        Args:
+            results: 订单数据列表
+        """
+        # 清空表格
+        self.result_table.setRowCount(0)
+        
+        if not results:
+            return
+        
+        # 定义表头和对应的字段名（完整列表）
+        columns = [
+            {"title": "序号", "field": None},
+            {"title": "日期", "field": "rq"},
+            {"title": "订单号", "field": "note"},
+            {"title": "订单明细", "field": "mo"},
+            {"title": "客户", "field": "customer"},
+            {"title": "客户订单号", "field": "khno"},  # 修改标题以区分
+            {"title": "订单类别", "field": "ddzl"},
+            {"title": "客户交期", "field": "khjq"},
+            {"title": "编码", "field": "code"},
+            {"title": "产品类别", "field": "type"},
+            {"title": "材质", "field": "cz"},
+            {"title": "规格", "field": "size"},
+            {"title": "产地", "field": "cd"},
+            {"title": "最大入库量", "field": "maxsl"},
+            {"title": "托盘号", "field": "spack"},
+            {"title": "轴型", "field": "zx_name"},
+            {"title": "轴型code", "field": "zx_code"},
+            {"title": "轴型重量", "field": "zx_zl"},
+            {"title": "标签类别", "field": "template_name"},
+            {"title": "标签类别code", "field": "bqlb"},
+            # 删除重复的"客户实际订单号"列
+            {"title": "打印材质", "field": "dycz"},
+            {"title": "炉号", "field": "luno"},
+            {"title": "公司", "field": "corp"},
+            {"title": "数量", "field": "sl"},
+            {"title": "上公差", "field": "tccd"},
+            {"title": "下公差", "field": "bccd"},
+            {"title": "延伸率", "field": "ysl"},
+            {"title": "屈服强度", "field": "qfqd"},
+            {"title": "英制规格", "field": "yzgg"},
+            {"title": "强度上限", "field": "tqd"},
+            {"title": "强度下限", "field": "bqd"},
+            {"title": "包装方式", "field": "bzfs"},
+            {"title": "订单要求", "field": "ddyq"},
+            {"title": "备注", "field": "remarks_hb"},
+            {"title": "包装强度上限", "field": "bz_tqd"},
+            {"title": "包装强度下限", "field": "bz_bqd"},
+            {"title": "轴重要求", "field": "zzyq"}
+        ]
+        
+        # 设置表头
+        self.result_table.setColumnCount(len(columns))
+        header_labels = [col["title"] for col in columns]
+        self.result_table.setHorizontalHeaderLabels(header_labels)
+        
+        # 设置行数
+        self.result_table.setRowCount(len(results))
+        
+        # 填充数据
+        for row, order_data in enumerate(results):
+            # 序号
+            item_index = QTableWidgetItem(str(row + 1))
+            item_index.setTextAlignment(Qt.AlignCenter)
+            self.result_table.setItem(row, 0, item_index)
+            
+            # 遍历列，填充数据
+            for col_idx, column in enumerate(columns[1:], 1):  # 从1开始，跳过序号列
+                field = column["field"]
+                if field:
+                    value = ""
+                    
+                    # 特殊处理某些字段
+                    if field == "rq":
+                        create_time = order_data.get(field, "")
+                        if create_time:
+                            try:
+                                # 尝试解析日期时间字符串
+                                dt = datetime.strptime(create_time, "%Y-%m-%d %H:%M:%S")
+                                value = dt.strftime("%Y-%m-%d")
+                            except:
+                                value = create_time
+                    else:
+                        # 其他普通字段
+                        value = str(order_data.get(field, ""))
+                    
+                    # 创建表格项并设置文本
+                    item = QTableWidgetItem(value)
+                    
+                    # 居中对齐特定的列
+                    if field in ["rq", "sl", "maxsl", "zx_zl"]:
+                        item.setTextAlignment(Qt.AlignCenter)
+                    
+                    # 设置表格项
+                    self.result_table.setItem(row, col_idx, item)
+            
+            # 存储原始数据到第一列的item中
+            item_index.setData(Qt.UserRole, order_data)
+    
+    def on_table_double_clicked(self, row, column):
+        """表格双击事件处理"""
+        self.select_current_row(row)
+    
+    def on_confirm(self):
+        """确认按钮点击事件处理"""
+        # 获取当前选中行
+        selected_rows = self.result_table.selectionModel().selectedRows()
+        if not selected_rows:
+            QMessageBox.warning(self, "提示", "请选择一个订单")
+            return
+        
+        # 获取选中行的索引
+        row_index = selected_rows[0].row()
+        self.select_current_row(row_index)
+    
+    def select_current_row(self, row):
+        """选择当前行并返回数据
+        
+        将订单明细(mo)作为订单号传递给上层组件
+        """
+        if 0 <= row < self.result_table.rowCount():
+            # 获取存储在item中的原始数据
+            item = self.result_table.item(row, 0)
+            if item:
+                order_data = item.data(Qt.UserRole)
+                if order_data:
+                    # 修改订单数据，将mo字段作为note字段的值
+                    # 这样上层组件接收到的订单号就是订单明细
+                    mo_value = order_data.get("mo", "")
+                    if mo_value:
+                        order_data["note"] = mo_value
+                    
+                    # 发出信号
+                    self.order_selected.emit(order_data)
+                    self.accept()