buff1.0/buff/other/XPBuffMainV1.0.py

import sys
from stringprep import in_table_c11

from PyQt6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QHBoxLayout, QWidget, QPushButton, QTabWidget, QLabel, QLineEdit, QTextEdit, QFormLayout, QMessageBox, QTreeWidget, QTreeWidgetItem, QDialog, QVBoxLayout as QDialogVBoxLayout, QLineEdit as QDialogLineEdit, QDialogButtonBox, QCheckBox, QComboBox
from PyQt6.QtCore import Qt
import requests as req
import time,random,numpy as np
import threading
import asyncio
import json
from PyQt6.QtWidgets import QFileDialog
from PyQt6.QtCore import pyqtSignal, QObject,pyqtSlot

class MainWindow(QMainWindow):
    # 定义一个信号，用于传递日志信息
    log_added = pyqtSignal(str, str, str, str, str, str, str, str)

    def __init__(self):
        super().__init__()

        # 设置一个选品停止的flag
        self.stop_selecting_flag = False
        # 设置一个扫货停止的flag
        self.stop_shopping_flag = False
        # 向BUFF选品日志列表中写内容的槽函数
        self.log_added.connect(self._add_select_log)  # 连接信号到槽函数

        self.goodsurl = 'https://buff.163.com/api/market/goods'
        self.getPaintwearChoicesUrl = 'https://buff.163.com/api/market/goods/info?goods_id='
        self.getPriceUrl = 'https://buff.163.com/api/market/goods/sell_order?game=csgo&page_num=1&sort_by=price.asc&goods_id='
        self.my_headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36",
            "Host": "buff.163.com",
            "Referer": "https://buff.163.com/market/?game=csgo",
            "X-Requested-With": "XMLHttpRequest"
        }

        # 初始化 phone_edit_map
        self.setup_phone_edit_map()

        # 设置窗口标题和大小
        self.setWindowTitle("垂直布局示例")
        self.setGeometry(100, 100, 1500, 800)

        # 创建一个垂直布局
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保垂直布局内容靠左对齐

        # 创建一个水平布局来放置按钮
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保水平布局内容靠左对齐

        # 创建两个按钮
        button1 = QPushButton("选品")
        button2 = QPushButton("扫货")

        # 增加停止选品和停止扫货按钮
        stop_select_button = QPushButton("停止选品")
        stop_shopping_button = QPushButton("停止扫货")
        button_layout.addWidget(button1)
        button_layout.addWidget(button2)
        button_layout.addWidget(stop_select_button)
        button_layout.addWidget(stop_shopping_button)

        # 连接按钮的点击事件
        button1.clicked.connect(self.show_selected_phone_number)
        button2.clicked.connect(self.show_shopping_phone_number)
        stop_select_button.clicked.connect(self.stop_selecting)  # 新增连接停止选品按钮的点击事件
        stop_shopping_button.clicked.connect(self.stop_shopping)  # 新增连接停止扫货按钮的点击事件

        # 将水平布局添加到垂直布局中
        layout.addLayout(button_layout)

        # 创建一个Tab容器
        self.tab_widget = QTabWidget()

        # 向Tab容器中添加10个标签页
        for i in range(1, 12):  # 修改循环范围以添加第11个标签页
            tab = QWidget()
            tab_layout = QVBoxLayout()
            tab_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保标签页布局内容靠左对齐
            if i == 1:
                form_layout = self.create_account_info_form("选品")
                tab_layout.addLayout(form_layout)
            elif i == 2:
                form_layout = self.create_account_info_form("扫货")
                tab_layout.addLayout(form_layout)
            elif i == 3:
                tree_layout = self.create_category_info_form()
                tab_layout.addLayout(tree_layout)
            elif i == 4:
                quality_layout = self.create_quality_info_form()
                tab_layout.addLayout(quality_layout)
            elif i == 5:
                type_layout = self.create_type_info_form()
                tab_layout.addLayout(type_layout)
            elif i == 6:
                appearance_layout = self.create_appearance_info_form()
                tab_layout.addLayout(appearance_layout)
            elif i == 7:
                collectible_layout = self.create_collectible_info_form()
                tab_layout.addLayout(collectible_layout)
            elif i == 8:
                config_layout = self.create_config_info_form("选品")
                tab_layout.addLayout(config_layout)
            elif i == 9:
                self.tab_widget.addTab(tab, "BUFF扫货配置")
            elif i == 10:
                select_log_layout = self.create_select_log_info_form()  # 添加BUFF选品日志标签页
                tab_layout.addLayout(select_log_layout)
            else:
                label = QLabel(f"这是标签页 {i}")
                tab_layout.addWidget(label)

            tab.setLayout(tab_layout)
            if i == 1:
                self.tab_widget.addTab(tab, "选品账号信息")
            elif i == 2:
                self.tab_widget.addTab(tab, "扫货账号信息")
            elif i == 3:
                self.tab_widget.addTab(tab, "BUFF品类信息")
            elif i == 4:
                self.tab_widget.addTab(tab, "BUFF品质信息")
            elif i == 5:
                self.tab_widget.addTab(tab, "BUFFTYPE信息")
            elif i == 6:
                self.tab_widget.addTab(tab, "BUFF外观信息")
            elif i == 7:
                self.tab_widget.addTab(tab, "BUFF收藏品信息")
            elif i == 8:
                self.tab_widget.addTab(tab, "BUFF选品配置")
            elif i == 9:
                self.tab_widget.addTab(tab, "BUFF扫货配置")
            elif i == 10:
                self.tab_widget.addTab(tab, "BUFF选品日志")
            else:
                self.tab_widget.addTab(tab, "BUFF扫货日志")

        # 将Tab容器添加到布局中
        layout.addWidget(self.tab_widget)

        # 创建一个中心部件，并将布局设置为中心部件的布局
        container = QWidget()
        container.setLayout(layout)

        # 将中心部件设置为主窗口的中心部件
        self.setCentralWidget(container)

    def create_account_info_form(self, prefix):
        form_layout = QFormLayout()
        form_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保表单布局内容靠左对齐

        # 创建输入框及其标签
        phone_label = QLabel(f"{prefix}手机号码")
        phone_edit = QLineEdit()
        phone_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        if prefix == "选品":
            phone_edit.setText("17756576757")  # 设置选品手机号码默认值
        form_layout.addRow(phone_label, phone_edit)

        email_label = QLabel(f"{prefix}邮箱号")
        email_edit = QLineEdit()
        email_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        if prefix == "选品":
            email_edit.setText("704541015@qq.com")  # 设置选品邮箱号默认值
        form_layout.addRow(email_label, email_edit)

        email_alias_label = QLabel(f"{prefix}邮箱特殊代码")
        email_alias_edit = QLineEdit()
        email_alias_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        if prefix == "选品":
            email_alias_edit.setText("100023")  # 设置选品邮箱特殊代码默认值
        form_layout.addRow(email_alias_label, email_alias_edit)

        cookie_label = QLabel(f"{prefix}cookie")
        cookie_edit = QTextEdit()  # 使用QTextEdit代替QLineEdit
        cookie_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        if prefix == "选品":
            cookie_edit.setText("_ntes_nnid=db955d39ec6952987ea31591e7a7f51e,1735042169953; _ntes_nuid=db955d39ec6952987ea31591e7a7f51e; _ga=GA1.1.1303944876.1735384064; _ga_EPDQHDTJH5=GS1.1.1735384063.1.1.1735384225.0.0.0; Device-Id=qX7ZJINOsL1UQiaTIf95; Locale-Supported=zh-Hans; game=csgo; NTES_YD_SESS=mxI7509dQOFnTUQL4erKAStVmmtgMVa2fLeArKiEwwfjhziQhoRng7jY76Fxt8Vx7Ug.rpFx_vgIUTnBU8WITvvsRbBJWpCgP5XKqRqj4dnxzwAXY7EB0k3RQSJVP6qBxmRQ3.4Dwg3N3zdbohGyDXYod7SqWwPf_ojsRYWGRA9juuEQBV5olV2BachLQOUPo_aaFTxdYDE4u.csB3dEd3FIOlk7iMX0Fo876uDHXUIju; S_INFO=1739607355|0|0&60##|17756576737; P_INFO=17756576737|1739607355|1|netease_buff|00&99|null&null&null#anh&341500#10#0|&0||17756576737; remember_me=U1084290368|NMXKtwDtRU9WpyahhliKCdNpCvsNz7Fm; session=1-MexohkheMA8hyDbqWC6qqjqXI51BN9AlucXjGPC00KgG2020502040; csrf_token=Ijk3MzdhYTQ1ZGZiNzVlODJiODRlMDgyY2FjNDZhYjFiOWM0ZTMyZjci.Z7Bd6w.WgVS2vOGY-azeRlsnOboVc2nuUE")  # 设置选品cookie默认值
        form_layout.addRow(cookie_label, cookie_edit)

        # 保存输入框的引用以便后续访问
        self.phone_edit_map[prefix] = phone_edit

        return form_layout

    def create_category_info_form(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保布局内容靠左对齐

        # 创建树形控件
        self.tree_widget = QTreeWidget()
        self.tree_widget.setHeaderLabels(["选择", "品类名称", "品类编码"])
        self.tree_widget.setColumnCount(3)
        self.tree_widget.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.tree_widget.setRootIsDecorated(True)  # 启用根节点的装饰
        self.tree_widget.setAlternatingRowColors(True)  # 设置交替行颜色
        self.tree_widget.setStyleSheet("QTreeWidget::item { padding: 5px; }")  # 设置项的内边距

        # 启用复选框
        self.tree_widget.setColumnWidth(0, 50)   # 设置选择列的宽度
        self.tree_widget.setColumnWidth(1, 300)  # 设置品类名称列的宽度
        self.tree_widget.setColumnWidth(2, 150)  # 设置品类编码列的宽度
        self.tree_widget.setHeaderItem(QTreeWidgetItem(["选择", "品类名称", "品类编码"]))  # 设置表头
        self.tree_widget.header().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置表头对齐方式

        # 添加默认的品类信息
        default_categories = [
            {"name": "蝴蝶刀", "code": "weapon_knife_butterfly"},
            {"name": "M9 刺刀", "code": "weapon_knife_m9_bayonet"},
            {"name": "爪子刀", "code": "weapon_knife_karambit"},
            {"name": "廓尔喀刀", "code": "weapon_knife_kke"}
        ]
        for category in default_categories:
            item = QTreeWidgetItem(self.tree_widget)
            item.setText(1, category["name"])
            item.setText(2, category["code"])
            checkbox = QCheckBox()
            checkbox.setChecked(False)
            self.tree_widget.setItemWidget(item, 0, checkbox)

        layout.addWidget(self.tree_widget)

        # 创建按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保按钮布局内容靠左对齐

        # 创建添加按钮
        add_button = QPushButton("添加")
        add_button.clicked.connect(self.add_category)
        button_layout.addWidget(add_button)

        # 创建删除按钮
        delete_button = QPushButton("删除")
        delete_button.clicked.connect(self.delete_category)
        button_layout.addWidget(delete_button)

        # 创建编辑按钮
        edit_button = QPushButton("编辑")
        edit_button.clicked.connect(self.edit_category)
        button_layout.addWidget(edit_button)

        layout.addLayout(button_layout)

        return layout

    def create_quality_info_form(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保布局内容靠左对齐

        # 创建树形控件
        self.quality_tree_widget = QTreeWidget()
        self.quality_tree_widget.setHeaderLabels(["选择", "品质编码", "品质名称"])
        self.quality_tree_widget.setColumnCount(3)
        self.quality_tree_widget.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.quality_tree_widget.setRootIsDecorated(True)  # 启用根节点的装饰
        self.quality_tree_widget.setAlternatingRowColors(True)  # 设置交替行颜色
        self.quality_tree_widget.setStyleSheet("QTreeWidget::item { padding: 5px; }")  # 设置项的内边距

        # 启用复选框
        self.quality_tree_widget.setColumnWidth(0, 50)   # 设置选择列的宽度
        self.quality_tree_widget.setColumnWidth(1, 150)  # 设置品质编码列的宽度
        self.quality_tree_widget.setColumnWidth(2, 300)  # 设置品质名称列的宽度
        self.quality_tree_widget.setHeaderItem(QTreeWidgetItem(["选择", "品质编码", "品质名称"]))  # 设置表头
        self.quality_tree_widget.header().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置表头对齐方式

        # 添加默认的品质信息
        default_qualities = [
            {"code": "contraband", "name": "违禁"},
            {"code": "ancient_weapon", "name": "隐秘"}
        ]
        for quality in default_qualities:
            item = QTreeWidgetItem(self.quality_tree_widget)
            item.setText(1, quality["code"])
            item.setText(2, quality["name"])
            checkbox = QCheckBox()
            checkbox.setChecked(False)
            self.quality_tree_widget.setItemWidget(item, 0, checkbox)

        layout.addWidget(self.quality_tree_widget)

        # 创建按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保按钮布局内容靠左对齐

        # 创建添加按钮
        add_button = QPushButton("添加")
        add_button.clicked.connect(self.add_quality)
        button_layout.addWidget(add_button)

        # 创建删除按钮
        delete_button = QPushButton("删除")
        delete_button.clicked.connect(self.delete_quality)
        button_layout.addWidget(delete_button)

        # 创建编辑按钮
        edit_button = QPushButton("编辑")
        edit_button.clicked.connect(self.edit_quality)
        button_layout.addWidget(edit_button)

        layout.addLayout(button_layout)

        return layout

    def create_type_info_form(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保布局内容靠左对齐

        # 创建树形控件
        self.type_tree_widget = QTreeWidget()
        self.type_tree_widget.setHeaderLabels(["选择", "type编码", "type名称"])
        self.type_tree_widget.setColumnCount(3)
        self.type_tree_widget.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.type_tree_widget.setRootIsDecorated(True)  # 启用根节点的装饰
        self.type_tree_widget.setAlternatingRowColors(True)  # 设置交替行颜色
        self.type_tree_widget.setStyleSheet("QTreeWidget::item { padding: 5px; }")  # 设置项的内边距

        # 启用复选框
        self.type_tree_widget.setColumnWidth(0, 50)   # 设置选择列的宽度
        self.type_tree_widget.setColumnWidth(1, 150)  # 设置type编码列的宽度
        self.type_tree_widget.setColumnWidth(2, 300)  # 设置type名称列的宽度
        self.type_tree_widget.setHeaderItem(QTreeWidgetItem(["选择", "type编码", "type名称"]))  # 设置表头
        self.type_tree_widget.header().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置表头对齐方式

        # 添加默认的type信息
        default_types = [
            {"code": "normal", "name": "普通"},
            {"code": "tournament", "name": "纪念品"}
        ]
        for type_info in default_types:
            item = QTreeWidgetItem(self.type_tree_widget)
            item.setText(1, type_info["code"])
            item.setText(2, type_info["name"])
            checkbox = QCheckBox()
            checkbox.setChecked(False)
            self.type_tree_widget.setItemWidget(item, 0, checkbox)

        layout.addWidget(self.type_tree_widget)

        # 创建按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保按钮布局内容靠左对齐

        # 创建添加按钮
        add_button = QPushButton("添加")
        add_button.clicked.connect(self.add_type)
        button_layout.addWidget(add_button)

        # 创建删除按钮
        delete_button = QPushButton("删除")
        delete_button.clicked.connect(self.delete_type)
        button_layout.addWidget(delete_button)

        # 创建编辑按钮
        edit_button = QPushButton("编辑")
        edit_button.clicked.connect(self.edit_type)
        button_layout.addWidget(edit_button)

        layout.addLayout(button_layout)

        return layout

    def create_appearance_info_form(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保布局内容靠左对齐

        # 创建树形控件
        self.appearance_tree_widget = QTreeWidget()
        self.appearance_tree_widget.setHeaderLabels(["选择", "外观编码", "外观名称"])
        self.appearance_tree_widget.setColumnCount(3)
        self.appearance_tree_widget.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.appearance_tree_widget.setRootIsDecorated(True)  # 启用根节点的装饰
        self.appearance_tree_widget.setAlternatingRowColors(True)  # 设置交替行颜色
        self.appearance_tree_widget.setStyleSheet("QTreeWidget::item { padding: 5px; }")  # 设置项的内边距

        # 启用复选框
        self.appearance_tree_widget.setColumnWidth(0, 50)   # 设置选择列的宽度
        self.appearance_tree_widget.setColumnWidth(1, 150)  # 设置外观编码列的宽度
        self.appearance_tree_widget.setColumnWidth(2, 300)  # 设置外观名称列的宽度
        self.appearance_tree_widget.setHeaderItem(QTreeWidgetItem(["选择", "外观编码", "外观名称"]))  # 设置表头
        self.appearance_tree_widget.header().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置表头对齐方式

        # 添加默认的外观信息
        default_appearances = [
            {"code": "wearcategory0", "name": "崭新出厂"},
            {"code": "wearcategory1", "name": "略有磨损"}
        ]
        for appearance in default_appearances:
            item = QTreeWidgetItem(self.appearance_tree_widget)
            item.setText(1, appearance["code"])
            item.setText(2, appearance["name"])
            checkbox = QCheckBox()
            checkbox.setChecked(False)
            self.appearance_tree_widget.setItemWidget(item, 0, checkbox)

        layout.addWidget(self.appearance_tree_widget)

        # 创建按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保按钮布局内容靠左对齐

        # 创建添加按钮
        add_button = QPushButton("添加")
        add_button.clicked.connect(self.add_appearance)
        button_layout.addWidget(add_button)

        # 创建删除按钮
        delete_button = QPushButton("删除")
        delete_button.clicked.connect(self.delete_appearance)
        button_layout.addWidget(delete_button)

        # 创建编辑按钮
        edit_button = QPushButton("编辑")
        edit_button.clicked.connect(self.edit_appearance)
        button_layout.addWidget(edit_button)

        layout.addLayout(button_layout)

        return layout

    def create_collectible_info_form(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保布局内容靠左对齐

        # 创建树形控件
        self.collectible_tree_widget = QTreeWidget()
        self.collectible_tree_widget.setHeaderLabels(["选择", "收藏品编码", "收藏品名称"])
        self.collectible_tree_widget.setColumnCount(3)
        self.collectible_tree_widget.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.collectible_tree_widget.setRootIsDecorated(True)  # 启用根节点的装饰
        self.collectible_tree_widget.setAlternatingRowColors(True)  # 设置交替行颜色
        self.collectible_tree_widget.setStyleSheet("QTreeWidget::item { padding: 5px; }")  # 设置项的内边距

        # 启用复选框
        self.collectible_tree_widget.setColumnWidth(0, 50)   # 设置选择列的宽度
        self.collectible_tree_widget.setColumnWidth(1, 150)  # 设置收藏品编码列的宽度
        self.collectible_tree_widget.setColumnWidth(2, 300)  # 设置收藏品名称列的宽度
        self.collectible_tree_widget.setHeaderItem(QTreeWidgetItem(["选择", "收藏品编码", "收藏品名称"]))  # 设置表头
        self.collectible_tree_widget.header().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置表头对齐方式

        # 添加默认的收藏品信息
        default_collectibles = [
            {"code": "C001", "name": "默认收藏品1"},
            {"code": "C002", "name": "默认收藏品2"}
        ]
        for collectible in default_collectibles:
            item = QTreeWidgetItem(self.collectible_tree_widget)
            item.setText(1, collectible["code"])
            item.setText(2, collectible["name"])
            checkbox = QCheckBox()
            checkbox.setChecked(False)
            self.collectible_tree_widget.setItemWidget(item, 0, checkbox)

        layout.addWidget(self.collectible_tree_widget)

        # 创建按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保按钮布局内容靠左对齐

        # 创建添加按钮
        add_button = QPushButton("添加")
        add_button.clicked.connect(self.add_collectible)
        button_layout.addWidget(add_button)

        # 创建删除按钮
        delete_button = QPushButton("删除")
        delete_button.clicked.connect(self.delete_collectible)
        button_layout.addWidget(delete_button)

        # 创建编辑按钮
        edit_button = QPushButton("编辑")
        edit_button.clicked.connect(self.edit_collectible)
        button_layout.addWidget(edit_button)

        layout.addLayout(button_layout)

        return layout

    def create_config_info_form(self, prefix):
        form_layout = QFormLayout()
        form_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保表单布局内容靠左对齐

        # 创建选品最低价输入框及其标签
        min_price_label = QLabel(f"{prefix}最低价")
        self.min_price_edit = QLineEdit()
        self.min_price_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        form_layout.addRow(min_price_label, self.min_price_edit)

        # 创建选品最高价输入框及其标签
        max_price_label = QLabel(f"{prefix}最高价")
        self.max_price_edit = QLineEdit()
        self.max_price_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        form_layout.addRow(max_price_label, self.max_price_edit)

        # 创建选品排序模式下拉选择框及其标签
        sort_mode_label = QLabel(f"{prefix}排序模式")
        self.sort_mode_combo = QComboBox()
        self.sort_mode_combo.addItems(["默认", "价格升序", "价格降序", "在售数量升序"])
        self.sort_mode_combo.setFixedWidth(500)  # 设置固定宽度为500像素
        form_layout.addRow(sort_mode_label, self.sort_mode_combo)

        # 创建选品停止条件下拉选择框及其标签
        stop_condition_label = QLabel(f"{prefix}停止条件")
        self.stop_condition_combo = QComboBox()
        self.stop_condition_combo.addItems(["按照成功数量", "按照扫描数量"])
        self.stop_condition_combo.setFixedWidth(500)  # 设置固定宽度为500像素
        form_layout.addRow(stop_condition_label, self.stop_condition_combo)

        # 创建成功数量配置输入框及其标签
        success_count_label = QLabel(f"{prefix}成功数量配置")
        self.success_count_edit = QLineEdit()
        self.success_count_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.success_count_edit.setText("100")  # 设置默认值为100
        form_layout.addRow(success_count_label, self.success_count_edit)

        # 创建扫描商品数量配置输入框及其标签
        scan_count_label = QLabel(f"{prefix}扫描商品数量")
        self.scan_count_edit = QLineEdit()
        self.scan_count_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.scan_count_edit.setText("10000")  # 设置默认值为10000
        form_layout.addRow(scan_count_label, self.scan_count_edit)

        # 创建选品接口每页请求数量配置输入框及其标签
        page_size_label = QLabel(f"{prefix}接口每页请求数量")
        self.page_size_edit = QLineEdit()
        self.page_size_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.page_size_edit.setText("80")  # 设置默认值为80
        form_layout.addRow(page_size_label, self.page_size_edit)

        # 创建每次调用BUFF接口暂停时间配置输入框及其标签
        pause_time_label = QLabel(f"{prefix}接口暂停时间(秒)")
        self.pause_time_edit = QLineEdit()
        self.pause_time_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.pause_time_edit.setText("10")  # 设置默认值为10
        form_layout.addRow(pause_time_label, self.pause_time_edit)

        # 创建选品接口最大请求多少页配置输入框及其标签
        max_pages_label = QLabel(f"{prefix}接口最大请求多少页")
        self.max_pages_edit = QLineEdit()
        self.max_pages_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.max_pages_edit.setText("100")  # 设置默认值为100
        form_layout.addRow(max_pages_label, self.max_pages_edit)

        # 创建商品参考价调整系数输入框及其标签
        ref_price_adjust_label = QLabel(f"{prefix}商品参考价调整系数%")
        self.ref_price_adjust_edit = QLineEdit()
        self.ref_price_adjust_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.ref_price_adjust_edit.setText("10")  # 设置默认值为10
        form_layout.addRow(ref_price_adjust_label, self.ref_price_adjust_edit)

        # 创建商品扫货价调整系数输入框及其标签
        sweep_price_adjust_label = QLabel(f"{prefix}商品扫货价调整系数%")
        self.sweep_price_adjust_edit = QLineEdit()
        self.sweep_price_adjust_edit.setFixedWidth(500)  # 设置固定宽度为500像素
        self.sweep_price_adjust_edit.setText("2")  # 设置默认值为2
        form_layout.addRow(sweep_price_adjust_label, self.sweep_price_adjust_edit)

        return form_layout

    def create_select_log_info_form(self):
        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保布局内容靠左对齐

        # 创建树形控件
        self.select_log_tree_widget = QTreeWidget()
        self.select_log_tree_widget.setHeaderLabels(["选择", "商品ID", "商品名称", "磨损最低值", "磨损最高值", "全磨损区间最低价", "扫货价", "判断价", "时间"])
        self.select_log_tree_widget.setColumnCount(9)
        self.select_log_tree_widget.setSelectionMode(QTreeWidget.SelectionMode.ExtendedSelection)
        self.select_log_tree_widget.setRootIsDecorated(True)  # 启用根节点的装饰
        self.select_log_tree_widget.setAlternatingRowColors(True)  # 设置交替行颜色
        self.select_log_tree_widget.setStyleSheet("QTreeWidget::item { padding: 5px; }")  # 设置项的内边距

        # 启用复选框
        self.select_log_tree_widget.setColumnWidth(0, 50)   # 设置选择列的宽度
        self.select_log_tree_widget.setColumnWidth(1, 100)  # 设置商品ID列的宽度
        self.select_log_tree_widget.setColumnWidth(2, 200)  # 设置商品名称列的宽度
        self.select_log_tree_widget.setColumnWidth(3, 100)  # 设置磨损最低值列的宽度
        self.select_log_tree_widget.setColumnWidth(4, 100)  # 设置磨损最高值列的宽度
        self.select_log_tree_widget.setColumnWidth(5, 150)  # 设置全磨损区间最低价列的宽度
        self.select_log_tree_widget.setColumnWidth(6, 100)  # 设置扫货价列的宽度
        self.select_log_tree_widget.setColumnWidth(7, 100)  # 设置判断价列的宽度
        self.select_log_tree_widget.setColumnWidth(8, 150)  # 设置时间列的宽度
        self.select_log_tree_widget.setHeaderItem(QTreeWidgetItem(["选择", "商品ID", "商品名称", "磨损最低值", "磨损最高值", "全磨损区间最低价", "扫货价", "判断价", "时间"]))  # 设置表头
        self.select_log_tree_widget.header().setDefaultAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置表头对齐方式

        layout.addWidget(self.select_log_tree_widget)

        # 创建按钮布局
        button_layout = QHBoxLayout()
        button_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 确保按钮布局内容靠左对齐

        # 创建添加按钮
        add_button = QPushButton("添加")
        add_button.clicked.connect(self.show_add_select_log_dialog)
        button_layout.addWidget(add_button)

        # 创建删除按钮
        delete_button = QPushButton("删除")
        delete_button.clicked.connect(self.delete_select_log)
        button_layout.addWidget(delete_button)

        # 创建编辑按钮
        edit_button = QPushButton("编辑")
        edit_button.clicked.connect(self.edit_select_log)
        button_layout.addWidget(edit_button)

        # 创建导出按钮
        export_button = QPushButton("导出")
        export_button.clicked.connect(self.export_selected_logs)
        button_layout.addWidget(export_button)

        layout.addLayout(button_layout)

        return layout

    def show_selected_phone_number(self):
        # 设置选品停止标志为False
        self.stop_selecting_flag = False

        # 必填条件，没有则跳出
        self.phone_number = self.phone_edit_map["选品"].text()
        QMessageBox.information(self, "选品手机号码", f"选品手机号码: {self.phone_number}")
        # 判断phone_number是否为空，为空则跳出方法
        if not self.phone_number:
            QMessageBox.information(self, "选品手机号码", "选品手机号码不能为空")
            return

        # 判断选品cookie是否为空，为空则退出方法
        self.cookie_text = self.phone_edit_map["选品"].parent().findChild(QTextEdit).toPlainText()
        if not self.cookie_text:
            QMessageBox.information(self, "选品Cookie", "选品Cookie不能为空")
            return

        # 获取勾选中的品类编码信息
        self.selected_categories = []
        # 获取勾选中的品类信息
        self.selected_categories_items = []
        for i in range(self.tree_widget.topLevelItemCount()):
            item = self.tree_widget.topLevelItem(i)
            checkbox = self.tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                category_code = item.text(2)
                category_name = item.text(1)
                self.selected_categories.append(category_code)
                self.selected_categories_items.append(f"{category_code}({category_name})")
        if self.selected_categories:
            QMessageBox.information(self, "勾选的品类信息", f"勾选的品类信息: {', '.join(self.selected_categories_items)}")
        else:
            QMessageBox.information(self, "勾选的品类信息", "没有勾选任何品类信息")

        # 获取勾选中的品质编码信息
        self.selected_qualities = []
        # 获取勾选中的品质信息
        self.selected_qualities_items = []
        for i in range(self.quality_tree_widget.topLevelItemCount()):
            item = self.quality_tree_widget.topLevelItem(i)
            checkbox = self.quality_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                quality_code = item.text(1)
                quality_name = item.text(2)
                self.selected_qualities.append(quality_code)
                self.selected_qualities_items.append(f"{quality_code}({quality_name})")
        if self.selected_qualities:
            QMessageBox.information(self, "勾选的品质信息", f"勾选的品质信息: {', '.join(self.selected_qualities_items)}")
        else:
            QMessageBox.information(self, "勾选的品质信息", "没有勾选任何品质信息")

        # 获取勾选中的type编码信息
        self.selected_types = []
        # 获取勾选中的type信息
        self.selected_types_items = []
        for i in range(self.type_tree_widget.topLevelItemCount()):
            item = self.type_tree_widget.topLevelItem(i)
            checkbox = self.type_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                type_code = item.text(1)
                type_name = item.text(2)
                self.selected_types.append(type_code)
                self.selected_types_items.append(f"{type_code}({type_name})")
        if self.selected_types:
            QMessageBox.information(self, "勾选的类别信息", f"勾选的类别信息: {', '.join(self.selected_types_items)}")
        else:
            QMessageBox.information(self, "勾选的类别信息", "没有勾选任何类别信息")

        # 获取勾选中的外观编码信息
        self.selected_appearances = []
        # 获取勾选中的外观信息
        self.selected_appearances_items = []
        for i in range(self.appearance_tree_widget.topLevelItemCount()):
            item = self.appearance_tree_widget.topLevelItem(i)
            checkbox = self.appearance_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                appearance_code = item.text(1)
                appearance_name = item.text(2)
                self.selected_appearances.append(appearance_code)
                self.selected_appearances_items.append(f"{appearance_code}({appearance_name})")
        if self.selected_appearances:
            QMessageBox.information(self, "勾选的外观信息", f"勾选的外观信息: {', '.join(self.selected_appearances_items)}")
        else:
            QMessageBox.information(self, "勾选的外观信息", "没有勾选任何外观信息")

        # 获取勾选中的收藏品编码信息
        self.selected_collectibles = []
        # 获取勾选中的收藏品信息
        self.selected_collectibles_items = []
        for i in range(self.collectible_tree_widget.topLevelItemCount()):
            item = self.collectible_tree_widget.topLevelItem(i)
            checkbox = self.collectible_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                collectible_code = item.text(1)
                collectible_name = item.text(2)
                self.selected_collectibles.append(collectible_code)
                self.selected_collectibles_items.append(f"{collectible_code}({collectible_name})")
        if self.selected_collectibles:
            QMessageBox.information(self, "勾选的收藏品信息", f"勾选的收藏品信息: {', '.join(self.selected_collectibles_items)}")
        else:
            QMessageBox.information(self, "勾选的收藏品信息", "没有勾选任何收藏品信息")

        # 获取选品配置信息
        self.min_price = self.min_price_edit.text()
        self.max_price = self.max_price_edit.text()
        self.sort_mode = self.sort_mode_combo.currentText()
        self.stop_condition = self.stop_condition_combo.currentText()
        self.success_count = self.success_count_edit.text()
        self.scan_count = self.scan_count_edit.text()
        self.page_size = self.page_size_edit.text()
        self.pause_time = self.pause_time_edit.text()
        #获取选品配置信息选品接口最大请求多少页
        self.max_page = self.max_pages_edit.text()
        #获取选品商品参考价调整系数
        self.ref_price_adjust = int(self.ref_price_adjust_edit.text())
        #获取选品商品扫货价调整系数
        self.sweep_price_adjust = int(self.sweep_price_adjust_edit.text())


        QMessageBox.information(self, "选品配置信息",
                                f"选品最低价: {self.min_price}\n"
                                f"选品最高价: {self.max_price}\n"
                                f"选品排序模式: {self.sort_mode}\n"
                                f"选品停止条件: {self.stop_condition}\n"
                                f"选品成功数量配置: {self.success_count}\n"
                                f"选品扫描商品数量: {self.scan_count}\n"
                                f"选品接口每页请求数量: {self.page_size}\n"
                                f"选品接口暂停时间(秒): {self.pause_time}\n"
                                f"选品接口最大请求多少页: {self.max_page}\n"
                                f"选品商品参考价调整系数%: {self.ref_price_adjust}\n"
                                f"选品商品扫货价调整系数%: {self.sweep_price_adjust}\n")
        try:
            thread_searchGoods = threading.Thread(target=self.firstSelectGoods)
            thread_searchGoods.start()

        except Exception as e:
            print(f"Error: {e}")

    def firstSelectGoods(self):

        # 组装商品选取API的入参list
        search_goods_param_list = []
        # 已经选品的数量
        self.searchedGoodsNum = 0
        # 已经选品成功的数量
        self.search_success_count = 0

        non_empty_lists = {
            'category': self.selected_categories,
            'rarity': self.selected_qualities,
            'quality': self.selected_types,
            'exterior': self.selected_appearances,
            'itemset': self.selected_collectibles
        }
        # 只保留非空的列表
        filtered_lists = {k: v for k, v in non_empty_lists.items() if v}

        # 如果所有列表都为空，返回空列表
        if not filtered_lists:
            print('品类、品质、类别、外观、收藏品的筛选条件都为空')
            search_goods_param_list = [{}]
        else:
            # 生成所有可能的组合
            # 使用itertools.product来生成所有可能的组合
            from itertools import product

            # 获取所有非空列表的值
            values = list(filtered_lists.values())
            # 获取所有非空列表的键
            keys = list(filtered_lists.keys())

            for combination in product(*values):
                combination_dict = {keys[i]: combination[i] for i in range(len(keys))}
                search_goods_param_list.append(combination_dict)

            for i in range(len(search_goods_param_list)):
                search_goods_param_list[i]['category_group'] = search_goods_param_list[i]['category']

        # 遍历search_goods_param_list
        for i in range(len(search_goods_param_list)):
            search_goods_param_list[i].update({ 'game': 'csgo'})
            # 判断min_price是否为空
            if self.min_price:
                search_goods_param_list[i]['min_price'] = self.min_price
            # 判断max_price是否为空
            if self.max_price:
                search_goods_param_list[i]['max_price'] = self.max_price
            # 判断sort_mode是否为空
            if self.sort_mode:
                if self.sort_mode == '默认':
                    pass
                elif self.sort_mode == '价格升序':
                    search_goods_param_list[i]['sort_by'] = 'price.asc'
                elif self.sort_mode == '价格降序':
                    search_goods_param_list[i]['sort_by'] = 'price.desc'
                elif self.sort_mode == '在售数量升序':
                    search_goods_param_list[i]['sort_by'] = 'sell_num.desc'
            # 判断选品接口每页请求数量是否为空
            if self.page_size:
                search_goods_param_list[i]['page_size'] = self.page_size
            # 选品接口每次的page_num 默认100
            if self.max_page:
                search_goods_param_list[i]['page_num'] = self.max_page
        print(f"请求网易BUFF商品的接口的入参为：{search_goods_param_list}")

        self.my_headers.update({
            'Cookie': self.cookie_text
        })

        try:
            print('选品接口请求参数列表 search_goods_param_list 长度:',len(search_goods_param_list))
            #遍历search_goods_param_list
            for i in range(len(search_goods_param_list)):
                try:
                    pagenum = self.max_page
                    j = pagenum
                    first_flag = True
                    while int(j) <= int(pagenum):
                        datalist=[]
                        if  not first_flag:
                            print(f"第{j}/{pagenum}页,API请求参数为：{search_goods_param_list[i]}")
                        else:
                            print(f"新查询条件第一次预请求,API请求参数为：{search_goods_param_list[i]}")
                        try:
                            # 开始时间为当前时间
                            start_time = time.time()
                            if  not first_flag:
                                search_goods_param_list[i]['page_num'] = j
                                # print('search_goods_param_list[i]12:',search_goods_param_list[i])
                            api1_res = req.get(url=self.goodsurl, headers=self.my_headers, params=search_goods_param_list[i])
                            print('选品接口请求返回报文:', api1_res.text.strip())
                            data = api1_res.json()['data']
                            print('选品接口请求返回报文中的CODE:', api1_res.json()['code'] )
                            #如果data中的code不等于OK，则跳出循环
                            if api1_res.json()['code'] != 'OK':
                                print('选品接口请求返回报文:', api1_res.text.strip())
                                print('选品接口请求返回报文code不等于OK，跳出循环')
                                continue
                            datalist.extend(data['items'])
                            # 遍历datalist
                            for k in range(len(datalist)):
                                print('k:',k)
                                # 做终止判断是否点击了停止选品按钮
                                if self.stop_selecting_flag:
                                    print('停止选品')
                                    return
                                # 判断选品停止条件来判断是否需要终止
                                if self.stop_condition == '按照成功数量':
                                    print(f'按照成功数量,设定的成功数量为:{self.success_count},当前检索已成功的数量为:{self.search_success_count}')
                                    if int(self.success_count) < int(self.search_success_count):
                                        return
                                else:
                                    #按照选品数量来判断是否要停止
                                    print(f'按照选品数量,设定的选品数量为:{self.scan_count},当前检索的选品数量为:{self.searchedGoodsNum}')
                                    if int(self.scan_count) < int(self.searchedGoodsNum):
                                        return
                                print('执行选品------------商品id:',str(datalist[k]["id"]))
                                # 选品的数量+1
                                self.searchedGoodsNum += 1
                                # 1、获取磨损
                                self.getPaintwearChoices(datalist[k]["id"])
                                if len(self.paintwear_choices) <= 0:
                                    print(f'获取商品id：{datalist[k]["id"]}磨损信息失败')
                                    continue
                                # 1、先获取全磨损的最低价 170
                                min_price = float(self.getPaintwearChoicesMinPrice(datalist[k]["id"],'',''))
                                #每个磨损区间的最低价
                                min_price_list = []
                                #2、获取每个磨损区间的最低价 270 260 230 240 170
                                break_flag = False
                                for i3 in range(len(self.paintwear_choices)):
                                    min_price_list.append(
                                        {
                                            'min_wear': self.paintwear_choices[i3][0],
                                            'max_wear': self.paintwear_choices[i3][1],
                                            'min_price':float(self.getPaintwearChoicesMinPrice(datalist[k]["id"],self.paintwear_choices[i3][0],self.paintwear_choices[i3][1]))
                                        }
                                    )
                                print(f'获取商品id：{datalist[k]["id"]}磨损区间及最低价信息:',min_price_list)
                                # todo 区间内容有价格为0，则跳过该商品，跳到下一个商品
                                for i2 in range(len(min_price_list)):
                                    if min_price_list[i2]['min_price'] == 0:
                                        print(f'获取商品id：{datalist[k]["id"]}磨损区间及最低价信息:',min_price_list)
                                        print(f'获取商品id：{datalist[k]["id"]}磨损区间及最低价信息中，有价格是0，跳过该商品')
                                        break_flag = True
                                if break_flag:
                                    continue

                                #3、全区间的最低价 170 * （1+10%），10%是设定的 = 187元
                                pd_price = round(min_price * (100 + self.ref_price_adjust) / 100 ,4)
                                #4、将5个磨损区间的最低价跟187比对，只留高于这个187价格的区间
                                # 遍历 min_price_list
                                for i1 in range(len(min_price_list)):
                                    if min_price_list[i1]['min_price'] < pd_price:
                                        # min_price_list 删除i1及以后的元素
                                        min_price_list = min_price_list[:i1]
                                        break
                                #5、根据阶梯来确定磨损区间
                                # 遍历 min_price_list，判断元素中的min_price是否小于上一个元素的min_price,
                                for i2 in range(len(min_price_list)-1):
                                    if min_price_list[i2]['min_price'] < min_price_list[i2+1]['min_price']:
                                        # min_price_list 删除i2及以后的元素
                                        min_price_list = min_price_list[:i2+1]
                                        break
                                #6、170*（1+0.02）= 173.4  购买溢价
                                gm_price = round(min_price * (100 + self.sweep_price_adjust) / 100,4)
                                # 向BUFF选品日志标签页中添加一条数据
                                timestamp = time.time()
                                local_time = time.localtime(timestamp)
                                formatted_time = time.strftime('%Y-%m-%d %H:%M:%S', local_time)
                                print(f'商品id：{datalist[k]["id"]} 筛选成功, 磨损及价格区间min_price_list:',min_price_list)
                                # min_price_list 为空则继续下次循环
                                if len(min_price_list) <= 0:
                                    continue
                                # 向BUFF选品日志标签页中增加记录 发出信号而不是直接调用 add_select_log
                                self.log_added.emit(str(datalist[k]["id"]), str(datalist[k]["name"]),str(min_price_list[0]['min_wear']), str(min_price_list[-1]['max_wear']), str(min_price), str(gm_price), str(pd_price), str(formatted_time))
                                #检索成功数量+1
                                self.search_success_count += 1

                            if  not first_flag:
                                j += 1

                            if first_flag:
                                if int(data['total_page']) < int(self.max_page) :
                                    pagenum = data['total_page']
                                j = 1
                                first_flag= False

                        except Exception as e:
                            print('选品接口1请求--失败',e)
                        finally:
                            # 结束时间为当前时间
                            end_time = time.time()
                            #从start_time到end_time 必须修改pause_time秒
                            if float(end_time - start_time) < float(self.pause_time):
                                time.sleep(float(self.pause_time) - (end_time - start_time) + random.randint(0, 5))
                except Exception as e:
                    print('选品接口2请求--失败',e)
        except Exception as e:
            print('选品接口3请求--失败',e)

    # 获取商品磨损信息
    def getPaintwearChoices(self,goods_id):
        print(f"获取商品id:{goods_id}的磨损信息" )
        self.paintwear_choices = []
        # 开始时间为当前时间
        start_time = time.time()
        self.my_headers.update({
            'Cookie': self.cookie_text
        })
        try:
            api2_res = req.get(url=self.getPaintwearChoicesUrl+str(goods_id), headers=self.my_headers)
            print(f'获取商品id:{goods_id}磨损信息请求的返回报文: {api2_res.text.strip()}')
            data = api2_res.json()['data']
            #如果data中的code不等于OK，则跳出循环
            if api2_res.json()['code'] != 'OK':
                print(f'获取商品id:{goods_id}磨损信息接口请求返回报文: {api2_res.text.strip()}')
                print(f'获取商品id:{goods_id}磨损信息接口请求返回报文code不等于OK，跳出循环')
                return
            self.paintwear_choices = data['paintwear_choices']
            print(f"获取商品id:{goods_id}的磨损信息:",self.paintwear_choices)
        except Exception as e:
            print(f'获取商品id:{goods_id}的磨损信息接口请求--失败',e)
        finally:
            # 结束时间为当前时间
            end_time = time.time()
            #从start_time到end_time 必须修改pause_time秒
            if float(end_time - start_time) < float(self.pause_time):
                time.sleep(float(self.pause_time) - (end_time - start_time) + random.randint(0, 5))

    # 获取磨损区间最低价格信息
    def getPaintwearChoicesMinPrice(self,goods_id,min_paint_wear,max_paint_wear):
        # min_paint_wear 为空 打印语句写成不限区间
        if min_paint_wear == '' and max_paint_wear == '':
            print(f"获取商品id：{goods_id}的磨损不限区间的最低价格" )
        else:
            print(f"获取商品id：{goods_id}的磨损区间{min_paint_wear}--{max_paint_wear}的最低价格" )
        # 开始时间为当前时间
        min_price = 0
        start_time = time.time()
        self.my_headers.update({
            'Cookie': self.cookie_text
        })
        url = self.getPriceUrl+str(goods_id)
        # min_paint_wear 不为空
        if min_paint_wear != '':
            print('min_paint_wear 最低磨损值 不为空')
            url += '&min_paintwear='+str(min_paint_wear)
        # max_paint_wear 不为空
        if max_paint_wear != '':
            print('max_paint_wear 最高磨损值 不为空')
            url += '&max_paintwear='+str(max_paint_wear)
        try:
            api2_res = req.get(url=url, headers=self.my_headers)
            print(f'获取商品id：{goods_id}磨损区间{min_paint_wear}--{max_paint_wear}最低价格请求的返回报文: {api2_res.text.strip()}')
            data = api2_res.json()['data']
            #如果data中的code不等于OK，则跳出循环
            if api2_res.json()['code'] != 'OK':
                print(f'获取商品id：{goods_id}磨损区间{min_paint_wear}--{max_paint_wear}最低价格请求返回报文: {api2_res.text.strip()}')
                print(f'获取商品id：{goods_id}磨损区间{min_paint_wear}--{max_paint_wear}最低价格返回报文code不等于OK，跳出循环')
                return
            min_price = data['items'][0]['price']
            print(f"商品id：{goods_id}的磨损区间{min_paint_wear}-{max_paint_wear}的最低价格:",min_price)
        except Exception as e:
            print(f'获取商品id：{goods_id}的磨损区间{min_paint_wear}-{max_paint_wear}的最低价格请求--失败,{e}')
        finally:
            # 结束时间为当前时间
            end_time = time.time()
            #从start_time到end_time 必须修改pause_time秒
            if float(end_time - start_time) < float(self.pause_time):
                time.sleep(float(self.pause_time) - (end_time - start_time) + random.randint(0, 5))
            return min_price

    def show_shopping_phone_number(self):
        phone_number = self.phone_edit_map["扫货"].text()
        QMessageBox.information(self, "扫货手机号码", f"扫货手机号码: {phone_number}")

        # 获取勾选中的品类编码信息
        selected_categories = []
        for i in range(self.tree_widget.topLevelItemCount()):
            item = self.tree_widget.topLevelItem(i)
            checkbox = self.tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                category_code = item.text(2)
                selected_categories.append(category_code)

        if selected_categories:
            QMessageBox.information(self, "勾选的品类编码", f"勾选的品类编码: {', '.join(selected_categories)}")
        else:
            QMessageBox.information(self, "勾选的品类编码", "没有勾选任何品类编码")

        # 获取勾选中的品质编码信息
        selected_qualities = []
        for i in range(self.quality_tree_widget.topLevelItemCount()):
            item = self.quality_tree_widget.topLevelItem(i)
            checkbox = self.quality_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                quality_code = item.text(1)
                selected_qualities.append(quality_code)

        if selected_qualities:
            QMessageBox.information(self, "勾选的品质编码", f"勾选的品质编码: {', '.join(selected_qualities)}")
        else:
            QMessageBox.information(self, "勾选的品质编码", "没有勾选任何品质编码")

        # 获取勾选中的type编码信息
        selected_types = []
        for i in range(self.type_tree_widget.topLevelItemCount()):
            item = self.type_tree_widget.topLevelItem(i)
            checkbox = self.type_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                type_code = item.text(1)
                selected_types.append(type_code)

        if selected_types:
            QMessageBox.information(self, "勾选的type编码", f"勾选的type编码: {', '.join(selected_types)}")
        else:
            QMessageBox.information(self, "勾选的type编码", "没有勾选任何type编码")

        # 获取勾选中的外观编码信息
        selected_appearances = []
        for i in range(self.appearance_tree_widget.topLevelItemCount()):
            item = self.appearance_tree_widget.topLevelItem(i)
            checkbox = self.appearance_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                appearance_code = item.text(1)
                selected_appearances.append(appearance_code)

        if selected_appearances:
            QMessageBox.information(self, "勾选的外观编码", f"勾选的外观编码: {', '.join(selected_appearances)}")
        else:
            QMessageBox.information(self, "勾选的外观编码", "没有勾选任何外观编码")

        # 获取勾选中的收藏品编码信息
        selected_collectibles = []
        for i in range(self.collectible_tree_widget.topLevelItemCount()):
            item = self.collectible_tree_widget.topLevelItem(i)
            checkbox = self.collectible_tree_widget.itemWidget(item, 0)
            if checkbox.isChecked():
                collectible_code = item.text(1)
                selected_collectibles.append(collectible_code)

        if selected_collectibles:
            QMessageBox.information(self, "勾选的收藏品编码", f"勾选的收藏品编码: {', '.join(selected_collectibles)}")
        else:
            QMessageBox.information(self, "勾选的收藏品编码", "没有勾选任何收藏品编码")

    def stop_selecting(self):
        # 在这里添加停止选品的逻辑
        # 设置选品停止标志为True
        self.stop_selecting_flag = True
        QMessageBox.information(self, "停止选品", "选品操作已终止")

    def stop_shopping(self):
        # 在这里添加停止扫货的逻辑
        QMessageBox.information(self, "停止扫货", "扫货操作已终止")

    def add_category(self):
        dialog = CategoryDialog(self, "添加品类")
        if dialog.exec():
            category_name = dialog.category_edit.text()
            category_code = dialog.category_code_edit.text()
            if category_name and category_code:
                item = QTreeWidgetItem(self.tree_widget)
                item.setText(1, category_name)
                item.setText(2, category_code)
                checkbox = QCheckBox()
                checkbox.setChecked(False)
                self.tree_widget.setItemWidget(item, 0, checkbox)

    def delete_category(self):
        selected_items = self.tree_widget.selectedItems()
        for item in selected_items:
            (item.parent() or self.tree_widget).takeTopLevelItem(self.tree_widget.indexOfTopLevelItem(item))

    def edit_category(self):
        selected_items = self.tree_widget.selectedItems()
        if len(selected_items) != 1:
            QMessageBox.warning(self, "编辑品类", "请选择一个品类进行编辑")
            return

        item = selected_items[0]
        dialog = CategoryDialog(self, "编辑品类", item.text(1), item.text(2))
        if dialog.exec():
            new_category_name = dialog.category_edit.text()
            new_category_code = dialog.category_code_edit.text()
            if new_category_name and new_category_code:
                item.setText(1, new_category_name)
                item.setText(2, new_category_code)

    def add_quality(self):
        dialog = QualityDialog(self, "添加品质")
        if dialog.exec():
            quality_code = dialog.quality_code_edit.text()
            quality_name = dialog.quality_name_edit.text()
            if quality_code and quality_name:
                item = QTreeWidgetItem(self.quality_tree_widget)
                item.setText(1, quality_code)
                item.setText(2, quality_name)
                checkbox = QCheckBox()
                checkbox.setChecked(False)
                self.quality_tree_widget.setItemWidget(item, 0, checkbox)

    def delete_quality(self):
        selected_items = self.quality_tree_widget.selectedItems()
        for item in selected_items:
            (item.parent() or self.quality_tree_widget).takeTopLevelItem(self.quality_tree_widget.indexOfTopLevelItem(item))

    def edit_quality(self):
        selected_items = self.quality_tree_widget.selectedItems()
        if len(selected_items) != 1:
            QMessageBox.warning(self, "编辑品质", "请选择一个品质进行编辑")
            return

        item = selected_items[0]
        dialog = QualityDialog(self, "编辑品质", item.text(1), item.text(2))
        if dialog.exec():
            new_quality_code = dialog.quality_code_edit.text()
            new_quality_name = dialog.quality_name_edit.text()
            if new_quality_code and new_quality_name:
                item.setText(1, new_quality_code)
                item.setText(2, new_quality_name)

    def add_type(self):
        dialog = TypeDialog(self, "添加type")
        if dialog.exec():
            type_code = dialog.type_code_edit.text()
            type_name = dialog.type_name_edit.text()
            if type_code and type_name:
                item = QTreeWidgetItem(self.type_tree_widget)
                item.setText(1, type_code)
                item.setText(2, type_name)
                checkbox = QCheckBox()
                checkbox.setChecked(False)
                self.type_tree_widget.setItemWidget(item, 0, checkbox)

    def delete_type(self):
        selected_items = self.type_tree_widget.selectedItems()
        for item in selected_items:
            (item.parent() or self.type_tree_widget).takeTopLevelItem(self.type_tree_widget.indexOfTopLevelItem(item))

    def edit_type(self):
        selected_items = self.type_tree_widget.selectedItems()
        if len(selected_items) != 1:
            QMessageBox.warning(self, "编辑type", "请选择一个type进行编辑")
            return

        item = selected_items[0]
        dialog = TypeDialog(self, "编辑type", item.text(1), item.text(2))
        if dialog.exec():
            new_type_code = dialog.type_code_edit.text()
            new_type_name = dialog.type_name_edit.text()
            if new_type_code and new_type_name:
                item.setText(1, new_type_code)
                item.setText(2, new_type_name)

    def add_appearance(self):
        dialog = AppearanceDialog(self, "添加外观")
        if dialog.exec():
            appearance_code = dialog.appearance_code_edit.text()
            appearance_name = dialog.appearance_name_edit.text()
            if appearance_code and appearance_name:
                item = QTreeWidgetItem(self.appearance_tree_widget)
                item.setText(1, appearance_code)
                item.setText(2, appearance_name)
                checkbox = QCheckBox()
                checkbox.setChecked(False)
                self.appearance_tree_widget.setItemWidget(item, 0, checkbox)

    def delete_appearance(self):
        selected_items = self.appearance_tree_widget.selectedItems()
        for item in selected_items:
            (item.parent() or self.appearance_tree_widget).takeTopLevelItem(self.appearance_tree_widget.indexOfTopLevelItem(item))

    def edit_appearance(self):
        selected_items = self.appearance_tree_widget.selectedItems()
        if len(selected_items) != 1:
            QMessageBox.warning(self, "编辑外观", "请选择一个外观进行编辑")
            return

        item = selected_items[0]
        dialog = AppearanceDialog(self, "编辑外观", item.text(1), item.text(2))
        if dialog.exec():
            new_appearance_code = dialog.appearance_code_edit.text()
            new_appearance_name = dialog.appearance_name_edit.text()
            if new_appearance_code and new_appearance_name:
                item.setText(1, new_appearance_code)
                item.setText(2, new_appearance_name)

    def add_collectible(self):
        dialog = CollectibleDialog(self, "添加收藏品")
        if dialog.exec():
            collectible_code = dialog.collectible_code_edit.text()
            collectible_name = dialog.collectible_name_edit.text()
            if collectible_code and collectible_name:
                item = QTreeWidgetItem(self.collectible_tree_widget)
                item.setText(1, collectible_code)
                item.setText(2, collectible_name)
                checkbox = QCheckBox()
                checkbox.setChecked(False)
                self.collectible_tree_widget.setItemWidget(item, 0, checkbox)

    def delete_collectible(self):
        selected_items = self.collectible_tree_widget.selectedItems()
        for item in selected_items:
            (item.parent() or self.collectible_tree_widget).takeTopLevelItem(self.collectible_tree_widget.indexOfTopLevelItem(item))

    def edit_collectible(self):
        selected_items = self.collectible_tree_widget.selectedItems()
        if len(selected_items) != 1:
            QMessageBox.warning(self, "编辑收藏品", "请选择一个收藏品进行编辑")
            return

        item = selected_items[0]
        dialog = CollectibleDialog(self, "编辑收藏品", item.text(1), item.text(2))
        if dialog.exec():
            new_collectible_code = dialog.collectible_code_edit.text()
            new_collectible_name = dialog.collectible_name_edit.text()
            if new_collectible_code and new_collectible_name:
                item.setText(1, new_collectible_code)
                item.setText(2, new_collectible_name)

    def setup_phone_edit_map(self):
        self.phone_edit_map = {}

    def show_add_select_log_dialog(self):
        dialog = SelectLogDialog(self, "添加选品日志")
        if dialog.exec():
            item_id = dialog.item_id_edit.text()
            item_name = dialog.item_name_edit.text()
            min_wear = dialog.min_wear_edit.text()
            max_wear = dialog.max_wear_edit.text()
            min_full_wear_price = dialog.min_full_wear_price_edit.text()
            sweep_price = dialog.sweep_price_edit.text()
            judge_price = dialog.judge_price_edit.text()
            timestamp = dialog.timestamp_edit.text()

            self.add_select_log(item_id, item_name, min_wear, max_wear, min_full_wear_price, sweep_price, judge_price, timestamp)

    def add_select_log(self, item_id, item_name, min_wear, max_wear, min_full_wear_price, sweep_price, judge_price, timestamp):
        # 创建一个字典来存储记录的详细信息
        record = {
            '商品ID': item_id,
            '商品名称': item_name,
            '磨损最低值': min_wear,
            '磨损最高值': max_wear,
            '全磨损区间最低价': min_full_wear_price,
            '扫货价': sweep_price,
            '判断价': judge_price,
            '时间': timestamp
        }

        # 将新记录添加到树形控件中
        item = QTreeWidgetItem(self.select_log_tree_widget)
        item.setText(0, "")  # 选择列为空
        item.setText(1, record['商品ID'])
        item.setText(2, record['商品名称'])
        item.setText(3, str(record['磨损最低值']))
        item.setText(4, str(record['磨损最高值']))
        item.setText(5, str(record['全磨损区间最低价']))
        item.setText(6, str(record['扫货价']))
        item.setText(7, str(record['判断价']))
        item.setText(8, record['时间'])

        # 创建复选框
        checkbox = QCheckBox()
        checkbox.setChecked(False)
        self.select_log_tree_widget.setItemWidget(item, 0, checkbox)

    # 向BUFF选品日志标签页的列表中写数据的槽函数
    @pyqtSlot(str, str, str, str, str, str, str, str)
    def _add_select_log(self, item_id, item_name, min_wear, max_wear, min_full_wear_price, sweep_price, judge_price, timestamp):
        # 创建一个字典来存储记录的详细信息
        record = {
            '商品ID': item_id,
            '商品名称': item_name,
            '磨损最低值': min_wear,
            '磨损最高值': max_wear,
            '全磨损区间最低价': min_full_wear_price,
            '扫货价': sweep_price,
            '判断价': judge_price,
            '时间': timestamp
        }

        # 将新记录添加到树形控件中
        item = QTreeWidgetItem(self.select_log_tree_widget)
        item.setText(0, "")  # 选择列为空
        item.setText(1, record['商品ID'])
        item.setText(2, record['商品名称'])
        item.setText(3, str(record['磨损最低值']))
        item.setText(4, str(record['磨损最高值']))
        item.setText(5, str(record['全磨损区间最低价']))
        item.setText(6, str(record['扫货价']))
        item.setText(7, str(record['判断价']))
        item.setText(8, record['时间'])

        # 创建复选框
        checkbox = QCheckBox()
        checkbox.setChecked(False)
        self.select_log_tree_widget.setItemWidget(item, 0, checkbox)

    def delete_select_log(self):
        # 获取选中的日志项
        selected_items = self.select_log_tree_widget.selectedItems()
        for item in selected_items:
            (item.parent() or self.select_log_tree_widget).takeTopLevelItem(self.select_log_tree_widget.indexOfTopLevelItem(item))


    def edit_select_log(self):
        # 获取选中的日志项
        selected_items = self.select_log_tree_widget.selectedItems()
        if len(selected_items) != 1:
            QMessageBox.warning(self, "编辑选品日志", "请选择一个选品日志进行编辑")
            return

        item = selected_items[0]
        # 获取当前选中的日志项的数据
        current_data = {
            '商品ID': item.text(1),
            '商品名称': item.text(2),
            '磨损最低值': item.text(3),
            '磨损最高值': item.text(4),
            '全磨损区间最低价': item.text(5),
            '扫货价': item.text(6),
            '判断价': item.text(7),
            '时间': item.text(8)
        }

        # 弹出编辑对话框
        dialog = EditSelectLogDialog(self, "编辑选品日志", current_data)
        if dialog.exec():
            # 获取编辑后的数据
            new_item_id = dialog.item_id_edit.text()
            new_item_name = dialog.item_name_edit.text()
            new_min_wear = dialog.min_wear_edit.text()
            new_max_wear = dialog.max_wear_edit.text()
            new_min_full_wear_price = dialog.min_full_wear_price_edit.text()
            new_sweep_price = dialog.sweep_price_edit.text()
            new_judge_price = dialog.judge_price_edit.text()
            new_timestamp = dialog.timestamp_edit.text()

            # 更新日志项的数据
            item.setText(1, new_item_id)
            item.setText(2, new_item_name)
            item.setText(3, new_min_wear)
            item.setText(4, new_max_wear)
            item.setText(5, new_min_full_wear_price)
            item.setText(6, new_sweep_price)
            item.setText(7, new_judge_price)
            item.setText(8, new_timestamp)

    def export_selected_logs(self):
        # 获取选中的日志项
        selected_items = self.select_log_tree_widget.selectedItems()
        if not selected_items:
            QMessageBox.warning(self, "导出选品日志", "请选择要导出的日志项")
            return

        # 将选中的日志项转换为字典列表
        logs = {}
        for item in selected_items:
            # log = {
            #     item.text(1):{
            #         "price":item.text(6),
            #         "min_paintwear":item.text(3),
            #         "max_paintwear" :item.text(4),
            #         "name":item.text(2),
            #         '商品ID': item.text(1),
            #         '商品名称': item.text(2),
            #         '磨损最低值': item.text(3),
            #         '磨损最高值': item.text(4),
            #         '全磨损区间最低价': item.text(5),
            #         '扫货价': item.text(6),
            #         '判断价': item.text(7),
            #         '时间': item.text(8)
            #     }
            # }
            logs[item.text(1)] = {
                "price":item.text(6),
                "min_paintwear":item.text(3),
                "max_paintwear" :item.text(4),
                "name":item.text(2),
                '商品ID': item.text(1),
                '商品名称': item.text(2),
                '磨损最低值': item.text(3),
                '磨损最高值': item.text(4),
                '全磨损区间最低价': item.text(5),
                '扫货价': item.text(6),
                '判断价': item.text(7),
                '时间': item.text(8)
            }
            # logs.append(log)

        # 选择保存文件的路径
        file_path, _ = QFileDialog.getSaveFileName(self, "导出选品日志", "", "JSON Files (*.json)")
        if file_path:
            try:
                with open(file_path, 'w', encoding='utf-8') as f:
                    json.dump(logs, f, ensure_ascii=False, indent=4)
                QMessageBox.information(self, "导出选品日志", f"日志已成功导出到 {file_path}")
            except Exception as e:
                QMessageBox.critical(self, "导出选品日志", f"导出日志时发生错误: {e}")

class EditSelectLogDialog(QDialog):
    def __init__(self, parent=None, title="编辑选品日志", initial_data=None):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 600, 400)

        layout = QDialogVBoxLayout()

        # 商品ID输入框
        item_id_label = QLabel("商品ID")
        self.item_id_edit = QDialogLineEdit()
        self.item_id_edit.setText(initial_data['商品ID'])
        layout.addWidget(item_id_label)
        layout.addWidget(self.item_id_edit)

        # 商品名称输入框
        item_name_label = QLabel("商品名称")
        self.item_name_edit = QDialogLineEdit()
        self.item_name_edit.setText(initial_data['商品名称'])
        layout.addWidget(item_name_label)
        layout.addWidget(self.item_name_edit)

        # 磨损最低值输入框
        min_wear_label = QLabel("磨损最低值")
        self.min_wear_edit = QDialogLineEdit()
        self.min_wear_edit.setText(str(initial_data['磨损最低值']))
        layout.addWidget(min_wear_label)
        layout.addWidget(self.min_wear_edit)

        # 磨损最高值输入框
        max_wear_label = QLabel("磨损最高值")
        self.max_wear_edit = QDialogLineEdit()
        self.max_wear_edit.setText(str(initial_data['磨损最高值']))
        layout.addWidget(max_wear_label)
        layout.addWidget(self.max_wear_edit)

        # 全磨损区间最低价输入框
        min_full_wear_price_label = QLabel("全磨损区间最低价")
        self.min_full_wear_price_edit = QDialogLineEdit()
        self.min_full_wear_price_edit.setText(str(initial_data['全磨损区间最低价']))
        layout.addWidget(min_full_wear_price_label)
        layout.addWidget(self.min_full_wear_price_edit)

        # 扫货价输入框
        sweep_price_label = QLabel("扫货价")
        self.sweep_price_edit = QDialogLineEdit()
        self.sweep_price_edit.setText(str(initial_data['扫货价']))
        layout.addWidget(sweep_price_label)
        layout.addWidget(self.sweep_price_edit)

        # 判断价输入框
        judge_price_label = QLabel("判断价")
        self.judge_price_edit = QDialogLineEdit()
        self.judge_price_edit.setText(str(initial_data['判断价']))
        layout.addWidget(judge_price_label)
        layout.addWidget(self.judge_price_edit)

        # 时间输入框
        timestamp_label = QLabel("时间")
        self.timestamp_edit = QDialogLineEdit()
        self.timestamp_edit.setText(initial_data['时间'])
        layout.addWidget(timestamp_label)
        layout.addWidget(self.timestamp_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)


class SelectLogDialog(QDialog):
    def __init__(self, parent=None, title="添加选品日志"):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 600, 400)

        layout = QDialogVBoxLayout()

        # 商品ID输入框
        item_id_label = QLabel("商品ID")
        self.item_id_edit = QDialogLineEdit()
        layout.addWidget(item_id_label)
        layout.addWidget(self.item_id_edit)

        # 商品名称输入框
        item_name_label = QLabel("商品名称")
        self.item_name_edit = QDialogLineEdit()
        layout.addWidget(item_name_label)
        layout.addWidget(self.item_name_edit)

        # 磨损最低值输入框
        min_wear_label = QLabel("磨损最低值")
        self.min_wear_edit = QDialogLineEdit()
        layout.addWidget(min_wear_label)
        layout.addWidget(self.min_wear_edit)

        # 磨损最高值输入框
        max_wear_label = QLabel("磨损最高值")
        self.max_wear_edit = QDialogLineEdit()
        layout.addWidget(max_wear_label)
        layout.addWidget(self.max_wear_edit)

        # 全磨损区间最低价输入框
        min_full_wear_price_label = QLabel("全磨损区间最低价")
        self.min_full_wear_price_edit = QDialogLineEdit()
        layout.addWidget(min_full_wear_price_label)
        layout.addWidget(self.min_full_wear_price_edit)

        # 扫货价输入框
        sweep_price_label = QLabel("扫货价")
        self.sweep_price_edit = QDialogLineEdit()
        layout.addWidget(sweep_price_label)
        layout.addWidget(self.sweep_price_edit)

        # 判断价输入框
        judge_price_label = QLabel("判断价")
        self.judge_price_edit = QDialogLineEdit()
        layout.addWidget(judge_price_label)
        layout.addWidget(self.judge_price_edit)

        # 时间输入框
        timestamp_label = QLabel("时间")
        self.timestamp_edit = QDialogLineEdit()
        layout.addWidget(timestamp_label)
        layout.addWidget(self.timestamp_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)

class CategoryDialog(QDialog):
    def __init__(self, parent=None, title="添加品类", initial_name="", initial_code=""):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 400, 150)

        layout = QDialogVBoxLayout()

        # 品类名称输入框
        name_label = QLabel("品类名称")
        self.category_edit = QDialogLineEdit()
        self.category_edit.setText(initial_name)
        layout.addWidget(name_label)
        layout.addWidget(self.category_edit)

        # 品类编码输入框
        code_label = QLabel("品类编码")
        self.category_code_edit = QDialogLineEdit()
        self.category_code_edit.setText(initial_code)
        layout.addWidget(code_label)
        layout.addWidget(self.category_code_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)

class QualityDialog(QDialog):
    def __init__(self, parent=None, title="添加品质", initial_code="", initial_name=""):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 400, 150)

        layout = QDialogVBoxLayout()

        # 品质编码输入框
        code_label = QLabel("品质编码")
        self.quality_code_edit = QDialogLineEdit()
        self.quality_code_edit.setText(initial_code)
        layout.addWidget(code_label)
        layout.addWidget(self.quality_code_edit)

        # 品质名称输入框
        name_label = QLabel("品质名称")
        self.quality_name_edit = QDialogLineEdit()
        self.quality_name_edit.setText(initial_name)
        layout.addWidget(name_label)
        layout.addWidget(self.quality_name_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)

class TypeDialog(QDialog):
    def __init__(self, parent=None, title="添加type", initial_code="", initial_name=""):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 400, 150)

        layout = QDialogVBoxLayout()

        # type编码输入框
        code_label = QLabel("type编码")
        self.type_code_edit = QDialogLineEdit()
        self.type_code_edit.setText(initial_code)
        layout.addWidget(code_label)
        layout.addWidget(self.type_code_edit)

        # type名称输入框
        name_label = QLabel("type名称")
        self.type_name_edit = QDialogLineEdit()
        self.type_name_edit.setText(initial_name)
        layout.addWidget(name_label)
        layout.addWidget(self.type_name_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)

class AppearanceDialog(QDialog):
    def __init__(self, parent=None, title="添加外观", initial_code="", initial_name=""):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 400, 150)

        layout = QDialogVBoxLayout()

        # 外观编码输入框
        code_label = QLabel("外观编码")
        self.appearance_code_edit = QDialogLineEdit()
        self.appearance_code_edit.setText(initial_code)
        layout.addWidget(code_label)
        layout.addWidget(self.appearance_code_edit)

        # 外观名称输入框
        name_label = QLabel("外观名称")
        self.appearance_name_edit = QDialogLineEdit()
        self.appearance_name_edit.setText(initial_name)
        layout.addWidget(name_label)
        layout.addWidget(self.appearance_name_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)

class CollectibleDialog(QDialog):
    def __init__(self, parent=None, title="添加收藏品", initial_code="", initial_name=""):
        super().__init__(parent)
        self.setWindowTitle(title)
        self.setGeometry(100, 100, 400, 150)

        layout = QDialogVBoxLayout()

        # 收藏品编码输入框
        code_label = QLabel("收藏品编码")
        self.collectible_code_edit = QDialogLineEdit()
        self.collectible_code_edit.setText(initial_code)
        layout.addWidget(code_label)
        layout.addWidget(self.collectible_code_edit)

        # 收藏品名称输入框
        name_label = QLabel("收藏品名称")
        self.collectible_name_edit = QDialogLineEdit()
        self.collectible_name_edit.setText(initial_name)
        layout.addWidget(name_label)
        layout.addWidget(self.collectible_name_edit)

        button_box = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
        button_box.accepted.connect(self.accept)
        button_box.rejected.connect(self.reject)
        layout.addWidget(button_box)

        self.setLayout(layout)



if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())