import os import sys import re from pathlib import Path from datetime import datetime, timedelta from typing import Any, Dict, List, Optional import pandas as pd from PyQt5.QtWidgets import ( QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLabel, QFileDialog, QTableWidgetItem, QMessageBox, QGridLayout, QStackedWidget, QButtonGroup, QStyle, QComboBox, QFrame, QShortcut, QMenu, QAbstractItemView, QTableView, QHeaderView, QTabWidget, QSplitter, QSizePolicy, QCheckBox ) from PyQt5.QtCore import Qt, QSortFilterProxyModel, QRegularExpression, QSettings, QTimer, QEvent from PyQt5.QtGui import QFont, QTextCursor, QKeySequence, QColor from qfluentwidgets import ( setTheme, Theme, PushButton, PrimaryPushButton, LineEdit, TextEdit, TableWidget, CheckBox, ProgressBar, CardWidget, InfoBar, InfoBarPosition ) from loguru import logger from gui_constants import get_default_folder_path, TABLE_HEADERS, MODEL_VIEW_HEADERS from gui_worker import WorkerThread from gui_models import ConfigTableModel, TableActionDelegate # --------------------------------------------------------------------------- # 主窗口 # --------------------------------------------------------------------------- class MainWindow(QMainWindow): """主窗口""" def __init__(self): super().__init__() self.worker_thread = None self.configs: List[Dict[str, Any]] = [] # 存储从Excel导入的配置 self.prepared_files = None # 存储通过"更新数据"找到的文件列表 self.running_total = 0 self.running_done = 0 self.nav_compact = False self.table_match_rows = [] self.table_match_index = -1 self.table_sort_keys = [] self.page_size = 20 self.current_page = 1 self.page_row_indices = [] self.filtered_config_indices = None # 文本/状态筛选后的配置索引，None 表示未筛选（显示全部） self.use_model_view = False # 批量任务队列相关 self.batch_task_queue = [] # 任务队列 self.current_batch_task_index = 0 # 当前任务索引 self.batch_total_tasks = 0 # 总任务数 self.batch_processed = 0 # 已处理任务数 self.batch_pending_tasks = 0 # 待处理任务数 self.batch_success_count = 0 # 成功数量 self.batch_failed_count = 0 # 失败数量 self._is_paused = False # 任务是否暂停 self._is_terminated = False # 任务是否被终止 self.table_model = None self.table_proxy = None self.log_match_positions = [] self.log_match_index = -1 self.is_updating_table = False self._is_closing = False # 标记是否正在关闭窗口 self._column_width_ratios = {} # 存储列宽比例，用于自动调整 self._is_manual_resize = False # 标记是否正在手动调整列宽 # 任务执行时用于“多多ID+序号 -> 行号”的映射（用于精确回写状态） self._row_map_by_user_index = {} # 以下属性在 init_ui() 中初始化，提前声明以满足 PyCharm 代码审查 self._table_view_column_width_ratios = {} self._is_table_view_manual_resize = False self._resize_timer = None self._table_view_resize_timer = None self._auto_resize_timer = None self._auto_resize_table_view_timer = None self.execute_btn = None self.pause_btn = None self.resume_btn = None self.terminate_btn = None self.status_update_value = None self.status_pending_value = None self.status_running_value = None self.status_success_value = None self.status_failed_value = None self.nav_card = None self.nav_title = None self.nav_divider = None self.nav_group = None self.nav_main = None self.nav_log = None self.nav_buttons = [] self.nav_footer = None self.nav_toggle_btn = None self.page_stack = None self.excel_path_input = None self.import_btn = None self.download_template_btn = None self.add_user_id_input = None self.add_index_input = None self.add_topic_input = None self.add_schedule_input = None self.add_interval_input = None self.add_expert_link_input = None self.add_executor_input = None self.add_config_btn = None self.clear_add_inputs_btn = None self.folder_path_input = None self.folder_browse_btn = None self.update_data_btn = None self.update_status_label = None self.batch_upload_checkbox = None self.batch_limit_input = None self.table_group = None self.table_edit_hint = None self.table_select_all_checkbox = None self.table_search_input = None self.table_column_filter = None self.table_highlight = None self.table_only_match = None self.table_prev_match_btn = None self.table_next_match_btn = None self.table_clear_btn = None self.table_export_all_btn = None self.table_select_count = None self.config_table = None self._filter_table_columns = [] self._filter_model_columns = [] self.table_view = None self.table_empty_label = None self.page_size_combo = None self.page_info_label = None self.page_first_btn = None self.page_prev_btn = None self.page_next_btn = None self.page_last_btn = None self.config_splitter = None self.workbench_tabs = None self.progress_bar = None self.log_search_input = None self.log_highlight_check = None self.log_whole_word = None self.log_prev_btn = None self.log_next_btn = None self.log_match_status = None self.log_export_btn = None self.clear_log_btn = None self.log_text = None self.shortcut_log_next = None self.shortcut_log_prev = None self._suppress_filter_clear_once = False self._current_status_filter = None self._update_data_running = False self.init_ui() def init_ui(self): # 初始化列宽调整相关的变量和定时器 if not hasattr(self, '_table_view_column_width_ratios'): self._table_view_column_width_ratios = {} if not hasattr(self, '_is_table_view_manual_resize'): self._is_table_view_manual_resize = False if not hasattr(self, '_resize_timer'): self._resize_timer = QTimer() self._resize_timer.setSingleShot(True) self._resize_timer.timeout.connect(self._delayed_update_ratios) if not hasattr(self, '_table_view_resize_timer'): self._table_view_resize_timer = QTimer() self._table_view_resize_timer.setSingleShot(True) self._table_view_resize_timer.timeout.connect(self._delayed_update_table_view_ratios) if not hasattr(self, '_auto_resize_timer'): self._auto_resize_timer = QTimer() self._auto_resize_timer.setSingleShot(True) self._auto_resize_timer.timeout.connect(self._auto_resize_table_columns) if not hasattr(self, '_auto_resize_table_view_timer'): self._auto_resize_table_view_timer = QTimer() self._auto_resize_table_view_timer.setSingleShot(True) self._auto_resize_table_view_timer.timeout.connect(self._auto_resize_table_view_columns) self.setWindowTitle("拼多多自动化发布工具") self.setGeometry(100, 100, 1000, 800) # 创建中央部件 central_widget = QWidget() self.setCentralWidget(central_widget) # 主布局 main_layout = QVBoxLayout() main_layout.setContentsMargins(20, 20, 20, 20) main_layout.setSpacing(14) central_widget.setLayout(main_layout) # 顶部标题区 header_layout = QHBoxLayout() title_box = QVBoxLayout() title_label = QLabel("拼多多自动化发布工具", None) title_label.setFont(QFont("Microsoft YaHei", 16, QFont.Bold)) subtitle_label = QLabel("配置导入 • 文件查找 • 批量上传", None) subtitle_label.setFont(QFont("Microsoft YaHei", 10)) title_box.addWidget(title_label) title_box.addWidget(subtitle_label) header_layout.addLayout(title_box) header_layout.addStretch() header_actions = QHBoxLayout() self.execute_btn = PrimaryPushButton("开始上传", None) self.execute_btn.clicked.connect(self.execute_task) header_actions.addWidget(self.execute_btn) self.pause_btn = PushButton("暂停", None) self.pause_btn.setVisible(False) self.pause_btn.clicked.connect(self.pause_task) self.pause_btn.setStyleSheet("QPushButton { background-color: #fff3e0; color: #e65100; }") header_actions.addWidget(self.pause_btn) self.resume_btn = PushButton("继续", None) self.resume_btn.setVisible(False) self.resume_btn.clicked.connect(self.resume_task) self.resume_btn.setStyleSheet("QPushButton { background-color: #e8f5e9; color: #2e7d32; }") header_actions.addWidget(self.resume_btn) self.terminate_btn = PushButton("终止", None) self.terminate_btn.setVisible(False) self.terminate_btn.clicked.connect(self.terminate_task) self.terminate_btn.setStyleSheet("QPushButton { background-color: #ffebee; color: #c62828; }") header_actions.addWidget(self.terminate_btn) header_layout.addLayout(header_actions) main_layout.addLayout(header_layout) # 状态卡片区 status_layout = QHBoxLayout() self.status_update_value = QLabel("未更新", None) self.status_pending_value = QLabel("0", None) self.status_running_value = QLabel("0", None) self.status_success_value = QLabel("0", None) self.status_failed_value = QLabel("0", None) update_card = self._build_status_card( "更新状态", self.status_update_value, self.style().standardIcon(QStyle.StandardPixmap.SP_BrowserReload), "#e6f4ff", "文件路径扫描" ) pending_card = self._build_status_card( "待执行", self.status_pending_value, self.style().standardIcon(QStyle.StandardPixmap.SP_FileDialogInfoView), "#fff7ed", "等待处理任务" ) running_card = self._build_status_card( "执行中", self.status_running_value, self.style().standardIcon(QStyle.StandardPixmap.SP_MediaPlay), "#ecfdf3", "当前执行进度", with_progress=True ) success_card = self._build_status_card( "成功", self.status_success_value, self.style().standardIcon(QStyle.StandardPixmap.SP_DialogApplyButton), "#dcfce7", "成功任务数量", clickable=False ) failed_card = self._build_status_card( "失败", self.status_failed_value, self.style().standardIcon(QStyle.StandardPixmap.SP_MessageBoxCritical), "#fee2e2", "失败任务数量", clickable=False ) status_layout.addWidget(update_card) status_layout.addWidget(pending_card) status_layout.addWidget(running_card) status_layout.addWidget(success_card) status_layout.addWidget(failed_card) main_layout.addLayout(status_layout) # 中间内容区（侧边导航 + 页面） content_layout = QHBoxLayout() content_layout.setSpacing(12) main_layout.addLayout(content_layout) nav_card = CardWidget() self.nav_card = nav_card nav_layout = QVBoxLayout(nav_card) nav_layout.setContentsMargins(10, 10, 10, 10) nav_layout.setSpacing(8) nav_card.setFixedWidth(150) nav_card.setStyleSheet(""" QPushButton { text-align: left; padding: 8px 10px; border-radius: 6px; border-left: 3px solid transparent; } QPushButton:hover { background-color: rgba(0, 120, 212, 0.08); } QPushButton:checked { background-color: rgba(0, 120, 212, 0.15); font-weight: 600; border-left: 3px solid #0078D4; } """) self.nav_title = QLabel("导航", None) self.nav_title.setFont(QFont("Microsoft YaHei", 10, QFont.Bold)) nav_layout.addWidget(self.nav_title) self.nav_divider = QFrame() self.nav_divider.setFrameShape(QFrame.HLine) self.nav_divider.setStyleSheet("color: rgba(0, 0, 0, 0.12);") nav_layout.addWidget(self.nav_divider) self.nav_group = QButtonGroup(self) self.nav_group.setExclusive(True) self.nav_main = PushButton("工作台", None) self.nav_log = PushButton("日志", None) nav_items = [ (self.nav_main, QStyle.StandardPixmap.SP_DesktopIcon), (self.nav_log, QStyle.StandardPixmap.SP_FileDialogContentsView), ] self.nav_buttons = [] for idx, (btn, icon_type) in enumerate(nav_items): btn.setCheckable(True) # 去掉左侧图标，避免在某些环境下图标位置异常遮挡中文文字 # 如果后续需要图标，可以在这里重新启用并配合样式表单独调整 padding # btn.setIcon(self.style().standardIcon(icon_type)) # btn.setIconSize(QSize(16, 16)) self.nav_group.addButton(btn, idx) nav_layout.addWidget(btn) self.nav_buttons.append(btn) nav_layout.addStretch() nav_footer_row = QHBoxLayout() self.nav_footer = QLabel("v1.0", None) self.nav_footer.setStyleSheet("color: #999; font-size: 10px;") nav_footer_row.addWidget(self.nav_footer) nav_footer_row.addStretch() self.nav_toggle_btn = PushButton("收起", None) self.nav_toggle_btn.clicked.connect(self.toggle_nav_compact) nav_footer_row.addWidget(self.nav_toggle_btn) nav_layout.addLayout(nav_footer_row) content_layout.addWidget(nav_card) self.page_stack = QStackedWidget() content_layout.addWidget(self.page_stack) content_layout.setStretch(1, 1) # 配置输入区域 config_group = CardWidget() config_layout = QVBoxLayout(config_group) config_layout.setContentsMargins(12, 12, 12, 12) config_title = QLabel("配置信息", None) config_title.setFont(QFont("Microsoft YaHei", 11, QFont.Bold)) config_layout.addWidget(config_title) config_group.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) config_group.setMaximumHeight(450) # 增加高度以容纳单条配置输入区域 # Excel导入（合并到配置） import_row = QHBoxLayout() import_row.addWidget(QLabel("Excel文件:", None)) self.excel_path_input = LineEdit() self.excel_path_input.setReadOnly(True) self.excel_path_input.setPlaceholderText("点击导入按钮选择Excel配置文件") import_row.addWidget(self.excel_path_input) self.import_btn = PrimaryPushButton("导入配置", None) self.import_btn.setToolTip("选择Excel文件并导入配置") self.import_btn.clicked.connect(self.import_excel) import_row.addWidget(self.import_btn) self.download_template_btn = PushButton("下载模板", None) self.download_template_btn.setToolTip("下载Excel配置模板文件") self.download_template_btn.clicked.connect(self.download_excel_template) import_row.addWidget(self.download_template_btn) config_layout.addLayout(import_row) # 添加单条配置输入区域 add_config_separator = QLabel("或 手动添加单条配置", None) add_config_separator.setFont(QFont("Microsoft YaHei", 9, QFont.Bold)) add_config_separator.setStyleSheet("color: #666; margin-top: 8px;") config_layout.addWidget(add_config_separator) # 单条配置输入表单 add_config_grid = QGridLayout() add_config_grid.setHorizontalSpacing(12) add_config_grid.setVerticalSpacing(8) # 第一行：多多ID、序号、话题 add_config_grid.addWidget(QLabel("多多ID:", None), 0, 0) self.add_user_id_input = LineEdit() self.add_user_id_input.setPlaceholderText("输入多多ID") add_config_grid.addWidget(self.add_user_id_input, 0, 1) add_config_grid.addWidget(QLabel("序号:", None), 0, 2) self.add_index_input = LineEdit() self.add_index_input.setPlaceholderText("输入序号") self.add_index_input.setFixedWidth(80) add_config_grid.addWidget(self.add_index_input, 0, 3) add_config_grid.addWidget(QLabel("话题:", None), 0, 4) self.add_topic_input = LineEdit() self.add_topic_input.setPlaceholderText("输入话题（如 #话题）") add_config_grid.addWidget(self.add_topic_input, 0, 5) # 第二行：定时发布、间隔时间、达人链接 add_config_grid.addWidget(QLabel("定时发布:", None), 1, 0) self.add_schedule_input = LineEdit() self.add_schedule_input.setPlaceholderText("yyyy-MM-dd HH:mm（可选）") add_config_grid.addWidget(self.add_schedule_input, 1, 1) add_config_grid.addWidget(QLabel("间隔(分):", None), 1, 2) self.add_interval_input = LineEdit() self.add_interval_input.setPlaceholderText("延迟分钟") self.add_interval_input.setFixedWidth(80) add_config_grid.addWidget(self.add_interval_input, 1, 3) add_config_grid.addWidget(QLabel("达人链接:", None), 1, 4) self.add_expert_link_input = LineEdit() self.add_expert_link_input.setPlaceholderText("输入达人链接（可选）") add_config_grid.addWidget(self.add_expert_link_input, 1, 5) # 第三行：执行人和添加按钮 add_config_grid.addWidget(QLabel("执行人:", None), 2, 0) self.add_executor_input = LineEdit() self.add_executor_input.setPlaceholderText("输入执行人（可选）") add_config_grid.addWidget(self.add_executor_input, 2, 1) add_config_btn_layout = QHBoxLayout() add_config_btn_layout.addStretch() self.add_config_btn = PrimaryPushButton("添加到配置列表", None) self.add_config_btn.setToolTip("将当前输入的配置添加到配置列表中") self.add_config_btn.clicked.connect(self.add_single_config) add_config_btn_layout.addWidget(self.add_config_btn) self.clear_add_inputs_btn = PushButton("清空输入", None) self.clear_add_inputs_btn.clicked.connect(self.clear_add_config_inputs) add_config_btn_layout.addWidget(self.clear_add_inputs_btn) add_config_grid.addLayout(add_config_btn_layout, 2, 2, 1, 4) config_layout.addLayout(add_config_grid) # 分隔线 divider = QFrame() divider.setFrameShape(QFrame.HLine) divider.setStyleSheet("color: rgba(0, 0, 0, 0.12); margin: 8px 0;") config_layout.addWidget(divider) grid = QGridLayout() grid.setHorizontalSpacing(12) grid.setVerticalSpacing(10) # 文件夹路径（最外层文件夹） grid.addWidget(QLabel("资料文件夹路径:", None), 0, 0) self.folder_path_input = LineEdit() default_path = get_default_folder_path() self.folder_path_input.setPlaceholderText(f"留空则使用默认路径: {default_path}") self.folder_path_input.setClearButtonEnabled(True) grid.addWidget(self.folder_path_input, 0, 1, 1, 2) self.folder_browse_btn = PushButton("浏览", None) self.folder_browse_btn.clicked.connect(self.browse_folder) grid.addWidget(self.folder_browse_btn, 0, 3) tip_label = QLabel("提示：只需填写最外层文件夹路径，程序会自动查找子文件夹中的文件", None) tip_label.setStyleSheet("color: #666; font-size: 10px;") grid.addWidget(tip_label, 1, 0, 1, 4) # 更新数据按钮 + 批量上传（同一行） update_row = QHBoxLayout() self.update_data_btn = PrimaryPushButton("更新数据", None) self.update_data_btn.clicked.connect(self.update_data) update_row.addWidget(self.update_data_btn) self.update_status_label = QLabel("未更新", None) self.update_status_label.setStyleSheet("color: #666; font-size: 10px;") update_row.addWidget(self.update_status_label) update_row.addStretch() self.batch_upload_checkbox = CheckBox("批量上传（如果文件夹中有多个视频，将使用批量上传模式）", None) self.batch_upload_checkbox.setChecked(False) update_row.addWidget(self.batch_upload_checkbox) # 添加间隔 update_row.addSpacing(20) # 单次上限数输入框 batch_limit_label = QLabel("单次上限数:", None) update_row.addWidget(batch_limit_label) self.batch_limit_input = LineEdit() self.batch_limit_input.setPlaceholderText("5") self.batch_limit_input.setText("5") self.batch_limit_input.setFixedWidth(50) self.batch_limit_input.setAlignment(Qt.AlignmentFlag.AlignCenter) self.batch_limit_input.setToolTip("每次批量上传的最大视频数量，超过则分批上传") update_row.addWidget(self.batch_limit_input) update_row_widget = QWidget() update_row_widget.setLayout(update_row) grid.addWidget(update_row_widget, 2, 0, 1, 4) config_layout.addLayout(grid) config_layout.addStretch() config_page = QWidget() config_page_layout = QVBoxLayout(config_page) config_page_layout.setContentsMargins(0, 0, 0, 0) config_page_layout.setSpacing(12) config_page_layout.addWidget(config_group) # 配置列表表格（如果从Excel导入） self.table_group = CardWidget() table_layout = QVBoxLayout(self.table_group) table_layout.setContentsMargins(12, 12, 12, 12) table_title = QLabel("配置列表（从Excel导入后显示，可直接在表格中编辑）", None) table_title.setFont(QFont("Microsoft YaHei", 11, QFont.Bold)) table_layout.addWidget(table_title) self.table_edit_hint = QLabel("编辑模式：当前行已高亮，其它行已锁定。修改后点击“确认”保存，点击“退出”还原。", None) self.table_edit_hint.setVisible(False) self.table_edit_hint.setStyleSheet( "background-color: #fff7ed; color: #9a3412; " "border: 1px solid #fed7aa; border-radius: 6px; padding: 6px 8px;" ) table_layout.addWidget(self.table_edit_hint) search_row = QHBoxLayout() self.table_select_all_checkbox = CheckBox("全选/取消", None) # noinspection PyUnresolvedReferences self.table_select_all_checkbox.stateChanged.connect(self.toggle_all_checkboxes) search_row.addWidget(self.table_select_all_checkbox) self.table_search_input = LineEdit() self.table_search_input.setPlaceholderText("搜索表格（支持空格多关键词）") self.table_search_input.setClearButtonEnabled(True) self.table_search_input.setFixedWidth(250) self.table_search_input.textChanged.connect(self.filter_table) search_row.addWidget(self.table_search_input) self.table_column_filter = QComboBox() self.table_column_filter.currentIndexChanged.connect(lambda: self.filter_table(self.table_search_input.text())) search_row.addWidget(self.table_column_filter) self.table_highlight = CheckBox("高亮匹配", None) self.table_highlight.setChecked(True) # noinspection PyUnresolvedReferences self.table_highlight.stateChanged.connect(lambda: self.filter_table(self.table_search_input.text())) search_row.addWidget(self.table_highlight) self.table_only_match = CheckBox("仅显示匹配项", None) self.table_only_match.setChecked(True) # noinspection PyUnresolvedReferences self.table_only_match.stateChanged.connect(lambda: self.filter_table(self.table_search_input.text())) search_row.addWidget(self.table_only_match) self.table_prev_match_btn = PushButton("上一条", None) self.table_prev_match_btn.clicked.connect(self.prev_table_match) search_row.addWidget(self.table_prev_match_btn) self.table_next_match_btn = PushButton("下一条", None) self.table_next_match_btn.clicked.connect(self.next_table_match) search_row.addWidget(self.table_next_match_btn) self.table_clear_btn = PushButton("清空筛选", None) self.table_clear_btn.clicked.connect(self._clear_filter_and_selection) search_row.addWidget(self.table_clear_btn) update_row.addSpacing(20) self.table_export_all_btn = PushButton("导出全部", None) self.table_export_all_btn.clicked.connect(self.export_all_rows) search_row.addWidget(self.table_export_all_btn) self.table_select_count = QLabel("已选: 0", None) self.table_select_count.setStyleSheet("color: #666; font-weight: bold;") search_row.addWidget(self.table_select_count) table_layout.addLayout(search_row) self.config_table = TableWidget() self.config_table.setStyleSheet(""" QTableView::item:selected { background-color: rgba(0, 120, 212, 0.18); } QTableView::item:hover { background-color: rgba(0, 120, 212, 0.08); } QHeaderView::section { background-color: #1f2937; color: #ffffff; padding: 8px; border: none; } QHeaderView::section:hover { background-color: #374151; } """) self.config_table.setColumnCount(12) self.config_table.setHorizontalHeaderLabels(TABLE_HEADERS) self.table_column_filter.addItem("全部列") # 第0列为勾选框；记录下拉项对应的表格列索引及 Model 列索引 self._filter_table_columns = [] self._filter_model_columns = [] # Model/View 无勾选列 for col in range(1, 10): header = self.config_table.horizontalHeaderItem(col) if header: self.table_column_filter.addItem(header.text()) self._filter_table_columns.append(col) # Model/View 列映射：1..8→0..7, 9→8 self._filter_model_columns.append(8 if col == 9 else col - 1) # 默认按多多ID筛选（多多ID为下拉第2项，index=1） if self._filter_table_columns and self._filter_table_columns[0] == 1: self.table_column_filter.setCurrentIndex(1) header = self.config_table.horizontalHeader() header.setStretchLastSection(True) # 设置所有列为Interactive模式，允许用户拖拽调整宽度 header.setSectionResizeMode(QHeaderView.Interactive) # 设置最小列宽，确保内容可见 header.setMinimumSectionSize(50) # 设置文本省略模式（超长文本显示省略号） self.config_table.setTextElideMode(Qt.TextElideMode.ElideRight) self.config_table.setAlternatingRowColors(True) self.config_table.setSortingEnabled(True) self.config_table.horizontalHeader().setSortIndicatorShown(True) self.config_table.verticalHeader().setVisible(False) self.config_table.verticalHeader().setDefaultSectionSize(42) # 禁用直接编辑，只能通过编辑按钮进入编辑模式 self.config_table.setEditTriggers(TableWidget.NoEditTriggers) self.config_table.setSelectionBehavior(QAbstractItemView.SelectRows) self.config_table.setSelectionMode(QAbstractItemView.ExtendedSelection) self.config_table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu) self.config_table.customContextMenuRequested.connect(self.show_table_context_menu) self.config_table.itemChanged.connect(self.on_table_item_changed) self.config_table.horizontalHeader().sectionClicked.connect(self.on_header_clicked) # 连接列宽调整信号，用于跟踪手动调整和自动调整 self.config_table.horizontalHeader().sectionResized.connect(self.on_column_resized) # 连接表格resize事件，用于自动按比例调整列宽 self.config_table.horizontalHeader().geometriesChanged.connect(self.on_table_geometry_changed) # 点击空白区域或按Esc键时退出编辑状态 self.config_table.viewport().installEventFilter(self) self.config_table.installEventFilter(self) table_layout.addWidget(self.config_table, 1) # stretch=1，占据剩余空间 # 大数据模式表格（Model/View） self.table_view = QTableView() self.table_view.setAlternatingRowColors(True) self.table_view.setSortingEnabled(True) self.table_view.verticalHeader().setVisible(False) self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows) self.table_view.setSelectionMode(QAbstractItemView.ExtendedSelection) # 设置文本省略模式（超长文本显示省略号） self.table_view.setTextElideMode(Qt.TextElideMode.ElideRight) self.table_view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu) self.table_view.customContextMenuRequested.connect(self.show_table_context_menu) self.table_view.setStyleSheet(""" QTableView::item:selected { background-color: rgba(0, 120, 212, 0.18); } QTableView::item:hover { background-color: rgba(0, 120, 212, 0.08); } QHeaderView::section { background-color: #1f2937; color: #ffffff; padding: 8px; border: none; } QHeaderView::section:hover { background-color: #374151; } """) self.table_view.setVisible(False) table_layout.addWidget(self.table_view, 1) # stretch=1，占据剩余空间 self.table_empty_label = QLabel("暂无数据，请先导入Excel配置", None) self.table_empty_label.setStyleSheet("color: #999; font-size: 12px;") self.table_empty_label.setAlignment(Qt.AlignmentFlag.AlignCenter) self.table_empty_label.setVisible(True) table_layout.addWidget(self.table_empty_label) # 分页控件行（不设置 stretch，固定在底部） pagination_row = QHBoxLayout() pagination_row.setContentsMargins(0, 8, 0, 0) pagination_row.addStretch() self.page_size_combo = QComboBox() self.page_size_combo.addItems(["10", "20", "50", "100"]) self.page_size_combo.setCurrentText(str(self.page_size)) self.page_size_combo.currentTextChanged.connect(self.change_page_size) pagination_row.addWidget(QLabel("每页", None)) pagination_row.addWidget(self.page_size_combo) self.page_info_label = QLabel("第 1/1 页", None) pagination_row.addWidget(self.page_info_label) self.page_first_btn = PushButton("首页", None) self.page_prev_btn = PushButton("上一页", None) self.page_next_btn = PushButton("下一页", None) self.page_last_btn = PushButton("末页", None) self.page_first_btn.clicked.connect(self.go_first_page) self.page_prev_btn.clicked.connect(self.go_prev_page) self.page_next_btn.clicked.connect(self.go_next_page) self.page_last_btn.clicked.connect(self.go_last_page) pagination_row.addWidget(self.page_first_btn) pagination_row.addWidget(self.page_prev_btn) pagination_row.addWidget(self.page_next_btn) pagination_row.addWidget(self.page_last_btn) table_layout.addLayout(pagination_row, 0) # stretch=0，固定大小 self.table_group.setVisible(True) self.table_group.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) # 配置 + 列表 分割布局 self.config_splitter = QSplitter(Qt.Orientation.Vertical) self.config_splitter.setChildrenCollapsible(True) self.config_splitter.addWidget(config_group) self.config_splitter.addWidget(self.table_group) self.config_splitter.setStretchFactor(0, 2) self.config_splitter.setStretchFactor(1, 3) self.config_splitter.splitterMoved.connect(self._save_splitter_sizes) config_page_layout.addWidget(self.config_splitter) self.page_stack.addWidget(config_page) # 工作台标签页 self.workbench_tabs = QTabWidget() self.workbench_tabs.addTab(config_page, "配置") workbench_page = QWidget() workbench_layout = QVBoxLayout(workbench_page) workbench_layout.setContentsMargins(0, 0, 0, 0) workbench_layout.addWidget(self.workbench_tabs) self.page_stack.addWidget(workbench_page) # 进度条（全局） self.progress_bar = ProgressBar() self.progress_bar.setVisible(False) main_layout.addWidget(self.progress_bar) # 日志显示区域 log_group = CardWidget() log_layout = QVBoxLayout(log_group) log_layout.setContentsMargins(12, 12, 12, 12) log_header = QHBoxLayout() log_title = QLabel("执行日志", None) log_title.setFont(QFont("Microsoft YaHei", 11, QFont.Bold)) log_header.addWidget(log_title) log_header.addStretch() self.log_search_input = LineEdit() self.log_search_input.setPlaceholderText("搜索日志") self.log_search_input.setClearButtonEnabled(True) self.log_search_input.textChanged.connect(self.filter_log) log_header.addWidget(self.log_search_input) self.log_highlight_check = CheckBox("高亮所有", None) self.log_highlight_check.setChecked(True) # noinspection PyUnresolvedReferences self.log_highlight_check.stateChanged.connect(lambda: self.filter_log(self.log_search_input.text())) log_header.addWidget(self.log_highlight_check) self.log_whole_word = CheckBox("整词匹配", None) # noinspection PyUnresolvedReferences self.log_whole_word.stateChanged.connect(lambda: self.filter_log(self.log_search_input.text())) log_header.addWidget(self.log_whole_word) self.log_prev_btn = PushButton("上一个", None) self.log_prev_btn.clicked.connect(lambda: self.find_log(backward=True)) log_header.addWidget(self.log_prev_btn) self.log_next_btn = PushButton("下一个", None) self.log_next_btn.clicked.connect(lambda: self.find_log(backward=False)) log_header.addWidget(self.log_next_btn) self.log_match_status = QLabel("匹配: 0", None) self.log_match_status.setStyleSheet("color: #666; font-size: 10px;") log_header.addWidget(self.log_match_status) # 初始化表格列宽比例 QTimer.singleShot(100, self._apply_table_column_widths) self.log_export_btn = PushButton("导出日志", None) self.log_export_btn.clicked.connect(self.export_log) log_header.addWidget(self.log_export_btn) self.clear_log_btn = PushButton("清空日志", None) self.clear_log_btn.clicked.connect(self.clear_log) log_header.addWidget(self.clear_log_btn) log_layout.addLayout(log_header) self.log_text = TextEdit() self.log_text.setReadOnly(True) self.log_text.setFont(QFont("Consolas", 10)) log_layout.addWidget(self.log_text) log_page = QWidget() log_page_layout = QVBoxLayout(log_page) log_page_layout.setContentsMargins(0, 0, 0, 0) log_page_layout.addWidget(log_group) self.page_stack.addWidget(log_page) # 配置日志输出（保留控制台输出，GUI通过信号接收） logger.remove() logger.add(lambda msg: None) # 禁用默认输出，通过信号在GUI中显示 # 默认选中工作台 self.nav_main.setChecked(True) self.page_stack.setCurrentIndex(0) self.nav_group.buttonClicked[int].connect(self.switch_page) self._restore_splitter_sizes() # 快捷键 self.shortcut_log_next = QShortcut(QKeySequence("F3"), self) self.shortcut_log_next.activated.connect(lambda: self.find_log(backward=False)) self.shortcut_log_prev = QShortcut(QKeySequence("Shift+F3"), self) self.shortcut_log_prev.activated.connect(lambda: self.find_log(backward=True)) # 程序启动时重置状态（不累计历史数据） self.set_status_cards(update_text="未更新", pending=0, running=0, success=0, failed=0) def _build_status_card(self, title, value_label, icon, bg_color, subtitle, with_progress=False, clickable=False): """创建状态卡片""" card = CardWidget() if clickable: card.setCursor(Qt.CursorShape.PointingHandCursor) card.setToolTip(subtitle) layout = QVBoxLayout(card) layout.setContentsMargins(12, 10, 12, 10) card.setStyleSheet(f"background-color: {bg_color};") icon_label = QLabel() icon_label.setPixmap(icon.pixmap(16, 16)) title_row = QHBoxLayout() title_label = QLabel(title) title_label.setFont(QFont("Microsoft YaHei", 9)) title_row.addWidget(icon_label) title_row.addWidget(title_label) title_row.addStretch() subtitle_label = QLabel(subtitle) subtitle_label.setStyleSheet("color: #666; font-size: 10px;") value_label.setFont(QFont("Microsoft YaHei", 12, QFont.Bold)) layout.addLayout(title_row) layout.addWidget(value_label) layout.addWidget(subtitle_label) if with_progress: self.status_running_progress = ProgressBar() self.status_running_progress.setRange(0, 100) self.status_running_progress.setValue(0) self.status_running_progress.setTextVisible(False) self.status_running_progress.setFixedHeight(6) layout.addWidget(self.status_running_progress) return card def switch_page(self, page_index): """切换侧边导航页面""" self.page_stack.setCurrentIndex(page_index) def eventFilter(self, obj, event): """事件过滤器：处理点击空白区域和按Esc键退出编辑状态""" # 处理表格viewport的鼠标点击事件 if obj == self.config_table.viewport() and event.type() == QEvent.Type.MouseButtonPress: # 获取点击位置对应的单元格 index = self.config_table.indexAt(event.pos()) if not index.isValid(): # 点击了空白区域，退出编辑状态 self._exit_table_edit_mode() return False # 继续传递事件 # 处理表格的键盘事件（Esc键退出编辑） if obj == self.config_table and event.type() == QEvent.Type.KeyPress: if event.key() == Qt.Key.Key_Escape: self._exit_table_edit_mode() return True # 阻止事件继续传递 return super().eventFilter(obj, event) def _exit_table_edit_mode(self): """退出表格编辑状态""" self.config_table.clearSelection() self.config_table.clearFocus() # 关闭当前编辑器 current_item = self.config_table.currentItem() if current_item: self.config_table.closePersistentEditor(current_item) self.config_table.setCurrentItem(None) # 恢复为只读模式 self.config_table.setEditTriggers(TableWidget.NoEditTriggers) self._cleanup_edit_mode_state() def _set_row_highlight(self, row, enabled): """高亮/取消高亮某一行""" highlight_color = QColor(255, 247, 216) for col in range(1, 10): # 数据列 1-9 item = self.config_table.item(row, col) if not item: continue if enabled: item.setBackground(highlight_color) else: item.setData(Qt.ItemDataRole.BackgroundRole, None) def _set_other_rows_locked(self, edit_row, locked): """锁定/解锁编辑行以外的行""" for r in range(self.config_table.rowCount()): if r == edit_row: # 编辑行保持可用 continue # 操作列按钮禁用/启用 action_widget = self.config_table.cellWidget(r, 11) if action_widget: action_widget.setEnabled(not locked) # 数据列禁用/启用 for col in range(1, 10): # 数据列 1-9 item = self.config_table.item(r, col) if not item: continue if locked: item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEnabled) else: item.setFlags((item.flags() | Qt.ItemFlag.ItemIsEnabled) & ~Qt.ItemFlag.ItemIsEditable) def _cleanup_edit_mode_state(self): """清理编辑态UI状态""" edit_row = getattr(self, '_editing_row', None) if edit_row is None: return self._set_row_highlight(edit_row, False) self._set_other_rows_locked(edit_row, False) self._editing_row = None if getattr(self, "table_edit_hint", None): self.table_edit_hint.setVisible(False) if hasattr(self, '_edit_selection_mode_backup'): self.config_table.setSelectionMode(self._edit_selection_mode_backup) def on_table_item_changed(self, item): """表格内容变更回调""" try: if not item: return # 防止递归调用：如果正在更新中，跳过 if self.is_updating_table: return # 检查 item 是否仍然有效（避免访问已删除的对象） try: row = item.row() col = item.column() text = item.text() except RuntimeError: # QTableWidgetItem 已被删除 return # 第8列：情况列，联动进度列的显示 if col == 8: # 设置标志，防止递归 self.is_updating_table = True try: self._set_status_item(row, text) self._set_progress_item(row, text) finally: self.is_updating_table = False # 其它可编辑列：同步当前行到 configs self._sync_config_from_row(row) except Exception as e: logger.warning(f"表格项改变回调出错: {e}") # 确保标志被重置 self.is_updating_table = False def _set_checkbox_item(self, row, config_index, row_height=None): """设置勾选框列（第0列）。row_height 传入时使用固定高度+居中对齐，避免第二行起勾选框往下错位。""" checkbox = QCheckBox() checkbox.blockSignals(True) checkbox.setChecked(self.configs[config_index].get('勾选', False)) # 默认不勾选 checkbox.blockSignals(False) # noinspection PyUnresolvedReferences checkbox.stateChanged.connect(lambda state, idx=config_index: self._on_checkbox_changed(idx, state)) checkbox.setStyleSheet( "QCheckBox { margin: 0px; padding: 0px; }" "QCheckBox::indicator { width: 20px; height: 20px; }" ) wrapper = QWidget() h = row_height if (row_height is not None and row_height > 0) else 42 wrapper.setFixedHeight(h) wrapper.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed) layout = QVBoxLayout(wrapper) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.setAlignment(Qt.AlignmentFlag.AlignCenter) layout.addWidget(checkbox) self.config_table.setCellWidget(row, 0, wrapper) def _sync_checked_from_table(self): """从表格当前页的勾选框同步勾选状态到 configs（仅非 model_view 且当前页）""" if self.use_model_view or not self.page_row_indices: return for table_row, config_index in enumerate(self.page_row_indices): if config_index >= len(self.configs): continue w = self.config_table.cellWidget(table_row, 0) if not w: continue checkbox = w.findChild(QCheckBox) if hasattr(w, 'findChild') else None if checkbox is not None: self.configs[config_index]['勾选'] = checkbox.isChecked() def _on_checkbox_changed(self, config_index, state): """勾选框状态改变回调""" if config_index < len(self.configs): self.configs[config_index]['勾选'] = (state == Qt.CheckState.Checked) # 更新已选数量显示 self._update_checked_count() # 更新状态统计 self._update_status_statistics() def _update_checked_count(self): """更新已勾选的数量显示""" if not hasattr(self, "table_select_count"): return checked_count = sum(1 for config in self.configs if config.get('勾选', False)) self.table_select_count.setText(f"已选: {checked_count}") def _clear_filter_and_selection(self): """清空筛选并取消所有勾选""" for config in self.configs: config['勾选'] = False if hasattr(self, 'table_select_all_checkbox'): self.table_select_all_checkbox.setChecked(False) self._current_status_filter = None self.filtered_config_indices = None # 清空搜索框会触发 filter_table("")，从而刷新为全量显示 self.table_search_input.setText("") self._update_checked_count() self._show_infobar("info", "已清空", "筛选条件和勾选已清空") def toggle_all_checkboxes(self): """全选/取消全选 - 跨页操作所有数据（考虑筛选条件）""" is_checked = self.table_select_all_checkbox.isChecked() visible_count = 0 # 有筛选时只操作筛选结果（filtered_config_indices），否则操作全部 indices = getattr(self, 'filtered_config_indices', None) if indices is not None: for config_index in indices: if 0 <= config_index < len(self.configs): self.configs[config_index]['勾选'] = is_checked visible_count += 1 else: for config_index in range(len(self.configs)): self.configs[config_index]['勾选'] = is_checked visible_count += 1 self.update_table() self._update_checked_count() self._update_status_statistics() if hasattr(self, 'table_search_input') and self.table_search_input.text().strip(): self._suppress_filter_clear_once = True self.filter_table(self.table_search_input.text()) if is_checked: self._show_infobar("success", "提示", f"已勾选 {visible_count} 行（跨页操作）") else: self._show_infobar("success", "提示", f"已取消 {visible_count} 行勾选（跨页操作）") @staticmethod def _create_centered_item(text): """创建居中对齐的表格单元格""" item = QTableWidgetItem(str(text)) item.setTextAlignment(Qt.AlignmentFlag.AlignCenter) # 默认不可编辑，必须通过编辑按钮进入编辑模式 item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable) return item def _set_status_item(self, row, text): """设置状态列文本""" try: # 使用 blockSignals 临时阻止信号，防止递归 self.config_table.blockSignals(True) try: item = QTableWidgetItem(text) item.setTextAlignment(Qt.AlignmentFlag.AlignCenter) # 居中对齐 item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable) # 根据状态设置文字颜色 if "完成" in text or "成功" in text: item.setForeground(QColor("#155724")) # 绿色 elif "失败" in text or "错误" in text: item.setForeground(QColor("#721C24")) # 红色 elif "执行中" in text or "进行" in text: item.setForeground(QColor("#0C5460")) # 蓝色 self._apply_current_highlight_to_item(row, 8, item, text) self.config_table.setItem(row, 8, item) finally: # 恢复信号 self.config_table.blockSignals(False) except Exception as e: logger.warning(f"设置状态项失败: {e}") # 确保信号恢复 self.config_table.blockSignals(False) def _set_progress_item(self, row, status_text): """设置进度列""" progress = ProgressBar() progress.setTextVisible(False) progress.setFixedHeight(8) progress.setRange(0, 100) value = 0 if "完成" in status_text or "成功" in status_text: value = 100 elif "执行中" in status_text or "进行" in status_text: value = 60 elif "待" in status_text: value = 10 progress.setValue(value) self.config_table.setCellWidget(row, 10, progress) def _set_action_buttons(self, row, config_index): """设置操作列按钮（编辑和删除）""" wrapper = QWidget() layout = QHBoxLayout(wrapper) layout.setContentsMargins(2, 0, 2, 0) layout.setSpacing(2) edit_btn = PushButton("编辑", None) edit_btn.setFixedWidth(52) edit_btn.setFixedHeight(32) edit_btn.setFont(QFont("Microsoft YaHei", 10)) delete_btn = PushButton("删除", None) delete_btn.setFixedWidth(52) delete_btn.setFixedHeight(32) delete_btn.setFont(QFont("Microsoft YaHei", 10)) # 使用默认参数捕获当前值，避免闭包问题 edit_btn.clicked.connect(lambda checked, r=row, idx=config_index: self._enter_edit_mode(r, idx)) delete_btn.clicked.connect(lambda checked, idx=config_index: self.delete_row_by_index(idx)) layout.addWidget(edit_btn) layout.addWidget(delete_btn) self.config_table.setCellWidget(row, 11, wrapper) def _set_edit_mode_buttons(self, row, config_index): """设置编辑模式按钮（确认和退出）""" wrapper = QWidget() layout = QHBoxLayout(wrapper) layout.setContentsMargins(2, 0, 2, 0) layout.setSpacing(2) confirm_btn = PushButton("确认", None) confirm_btn.setFixedWidth(52) confirm_btn.setFixedHeight(32) confirm_btn.setFont(QFont("Microsoft YaHei", 10)) cancel_btn = PushButton("退出", None) cancel_btn.setFixedWidth(52) cancel_btn.setFixedHeight(32) cancel_btn.setFont(QFont("Microsoft YaHei", 10)) # 使用默认参数捕获当前值 confirm_btn.clicked.connect(lambda checked, r=row, idx=config_index: self._confirm_edit(r, idx)) cancel_btn.clicked.connect(lambda checked, r=row, idx=config_index: self._cancel_edit(r, idx)) layout.addWidget(confirm_btn) layout.addWidget(cancel_btn) self.config_table.setCellWidget(row, 11, wrapper) def _enter_edit_mode(self, row, config_index): """进入编辑模式""" if row < 0 or row >= self.config_table.rowCount(): return # 允许当前行进入编辑时的交互触发 if not hasattr(self, '_edit_triggers_backup'): self._edit_triggers_backup = self.config_table.editTriggers() self.config_table.setEditTriggers(QAbstractItemView.DoubleClicked | QAbstractItemView.SelectedClicked) if not hasattr(self, '_edit_selection_mode_backup'): self._edit_selection_mode_backup = self.config_table.selectionMode() self.config_table.setSelectionMode(QAbstractItemView.SingleSelection) self._editing_row = row # 保存原始数据用于还原 if not hasattr(self, '_edit_backup'): self._edit_backup = {} original_data = {} for col in range(1, 10): # 1-9列是数据列 item = self.config_table.item(row, col) original_data[col] = item.text() if item else "" self._edit_backup[row] = original_data # 启用该行的编辑 for col in range(1, 10): item = self.config_table.item(row, col) if item: item.setFlags(item.flags() | Qt.ItemFlag.ItemIsEditable) # 高亮编辑行并锁定其他行 self._set_row_highlight(row, True) self._set_other_rows_locked(row, True) # 切换到编辑模式按钮 self._set_edit_mode_buttons(row, config_index) # 自动聚焦第一个可编辑单元格 first_item = None for col in range(1, 10): item = self.config_table.item(row, col) if item and (item.flags() & Qt.ItemFlag.ItemIsEditable): first_item = item self.config_table.setCurrentCell(row, col) break if first_item: self.config_table.setFocus(Qt.FocusReason.TabFocusReason) self.config_table.scrollToItem(first_item, QAbstractItemView.PositionAtCenter) self.config_table.editItem(first_item) if self.table_edit_hint: self.table_edit_hint.setVisible(True) self._show_infobar("info", "编辑模式", f"正在编辑第 {row + 1} 行，修改后点击确认保存或退出还原") def _confirm_edit(self, row, config_index): """确认编辑并保存""" if row < 0 or row >= self.config_table.rowCount(): return # 同步表格数据到configs self._sync_config_from_row(row) # 禁用该行的编辑 for col in range(1, 10): item = self.config_table.item(row, col) if item: item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable) # 清除备份 if hasattr(self, '_edit_backup') and row in self._edit_backup: del self._edit_backup[row] # 恢复操作按钮 self._set_action_buttons(row, config_index) self._show_infobar("success", "保存成功", f"第 {row + 1} 行数据已保存") # 退出编辑模式后恢复为只读 self.config_table.setEditTriggers(TableWidget.NoEditTriggers) self._cleanup_edit_mode_state() def _cancel_edit(self, row, config_index): """取消编辑并还原数据""" if row < 0 or row >= self.config_table.rowCount(): return # 还原原始数据 if hasattr(self, '_edit_backup') and row in self._edit_backup: original_data = self._edit_backup[row] # 临时断开信号防止触发同步 self.is_updating_table = True try: for col, value in original_data.items(): if col == 8: self._set_status_item(row, value) self._set_progress_item(row, value) else: item = self.config_table.item(row, col) if item: item.setText(value) # 确保清除编辑标志 item = self.config_table.item(row, col) if item: item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable) finally: self.is_updating_table = False del self._edit_backup[row] # 恢复操作按钮 self._set_action_buttons(row, config_index) self._show_infobar("info", "已退出", f"第 {row + 1} 行数据已还原") # 退出编辑模式后恢复为只读 self.config_table.setEditTriggers(TableWidget.NoEditTriggers) self._cleanup_edit_mode_state() def delete_row_by_index(self, row): """删除指定行""" if row < 0 or row >= len(self.configs): return self.configs.pop(row) self.update_table() def _sync_config_from_row(self, row): """同步表格行到configs""" if row < 0 or row >= self.config_table.rowCount(): return if not self.page_row_indices: return if row >= len(self.page_row_indices): return config_index = self.page_row_indices[row] if config_index >= len(self.configs): return # 第0列是勾选框，数据列从第1列开始 def cell(col): item = self.config_table.item(row, col + 1) return item.text().strip() if item else "" self.configs[config_index].update({ "多多id": cell(0), "序号": cell(1), "话题": cell(2), "定时发布": cell(3), "间隔时间": cell(4), "达人链接": cell(5), "执行人": cell(6), "情况": cell(7) or "待执行", "文件路径": cell(8), }) def _sync_configs_from_table(self): """从表格同步当前页配置（跳过空行）""" if not self.page_row_indices: return for row, config_index in enumerate(self.page_row_indices): if config_index >= len(self.configs): continue # 第0列是勾选框，数据列从第1列开始 def cell(col): item = self.config_table.item(row, col + 1) return item.text().strip() if item else "" # 判断是否为空行（避免把空白占位行写回） values = [cell(i) for i in range(1, 10)] if not any(values): continue self.configs[config_index].update({ "多多id": cell(0), "序号": cell(1), "话题": cell(2), "定时发布": cell(3), "间隔时间": cell(4), "达人链接": cell(5), "执行人": cell(6), "情况": cell(7) or "待执行", "文件路径": cell(8), }) def _save_splitter_sizes(self): """保存分割器尺寸""" if not hasattr(self, "config_splitter"): return settings = QSettings("haha", "gui_app") settings.setValue("config_splitter_sizes", self.config_splitter.sizes()) def _restore_splitter_sizes(self): """恢复分割器尺寸""" if not hasattr(self, "config_splitter"): return settings = QSettings("haha", "gui_app") sizes = settings.value("config_splitter_sizes") if sizes: self.config_splitter.setSizes([int(s) for s in sizes]) else: # 首次默认：配置区偏大 self.config_splitter.setSizes([450, 550]) def change_page_size(self, value): """修改分页大小""" try: self.page_size = int(value) except ValueError: self.page_size = 20 self.current_page = 1 self.update_table() def go_first_page(self): """首页""" self.current_page = 1 self.update_table() def go_prev_page(self): """上一页""" if self.current_page > 1: self.current_page -= 1 self.update_table() def go_next_page(self): """下一页""" total_rows = len(self.configs) total_pages = max(1, (total_rows + self.page_size - 1) // self.page_size) if self.current_page < total_pages: self.current_page += 1 self.update_table() def go_last_page(self): """末页""" total_rows = len(self.configs) total_pages = max(1, (total_rows + self.page_size - 1) // self.page_size) self.current_page = total_pages self.update_table() def on_header_clicked(self, logical_index): """处理多列排序（Ctrl 多选）""" # 0列为勾选框，10/11列为进度/操作，禁止排序 if logical_index == 0 or logical_index >= 10: return modifiers = QApplication.keyboardModifiers() is_multi = modifiers & Qt.KeyboardModifier.ControlModifier existing: Optional[int] = next((i for i, (col, _) in enumerate(self.table_sort_keys) if col == logical_index), None) if existing is not None: col, order = self.table_sort_keys[int(existing)] new_order = Qt.SortOrder.DescendingOrder if order == Qt.SortOrder.AscendingOrder else Qt.SortOrder.AscendingOrder self.table_sort_keys[int(existing)] = (col, new_order) else: if not is_multi: self.table_sort_keys = [] self.table_sort_keys.append((logical_index, Qt.SortOrder.AscendingOrder)) self._sort_table_by_keys() def _sort_table_by_keys(self): """按多列排序表格""" if not self.table_sort_keys: return self._sync_configs_from_table() key_map = { 1: "多多id", 2: "序号", 3: "话题", 4: "定时发布", 5: "间隔时间", 6: "达人链接", 7: "执行人", 8: "情况", 9: "文件路径", } # 数字类型的列（需要按数字排序） numeric_fields = {"序号", "间隔时间"} def get_sort_key(cfg, field): """获取排序键值，数字列按数字排序""" value = cfg.get(field, "") if field in numeric_fields: try: # 尝试转换为数字进行排序 return (0, float(str(value)) if value else 0) except (ValueError, TypeError): # 转换失败则作为字符串排序，排在数字后面 return (1, str(value)) return (0, str(value)) for col, order in reversed(self.table_sort_keys): sort_field = key_map.get(col, "") self.configs.sort( key=lambda cfg, f=sort_field: get_sort_key(cfg, f), reverse=(order == Qt.SortOrder.DescendingOrder) ) self.update_table() def show_table_context_menu(self, pos): """表格右键菜单""" menu = QMenu(self) copy_action = menu.addAction("复制选中行") export_csv_action = menu.addAction("导出选中行CSV") export_excel_action = menu.addAction("导出选中行Excel") delete_action = menu.addAction("删除选中行") view = self.table_view if self.use_model_view else self.config_table action = menu.exec_(view.viewport().mapToGlobal(pos)) if action == copy_action: self.copy_selected_rows() elif action == delete_action: self.delete_selected_rows() elif action == export_csv_action: self.export_selected_rows("csv") elif action == export_excel_action: self.export_selected_rows("excel") def copy_selected_rows(self): """复制选中行到剪贴板""" if self.use_model_view: if not self.table_view.selectionModel(): return rows = [idx.row() for idx in self.table_view.selectionModel().selectedRows()] if not rows: return lines = [] for row in sorted(set(rows)): values = [] for col in range(9): idx = self.table_proxy.index(row, col) values.append(str(self.table_proxy.data(idx))) lines.append("\t".join(values)) QApplication.clipboard().setText("\n".join(lines)) return ranges = self.config_table.selectedRanges() if not ranges: return rows = set() for r in ranges: rows.update(range(r.topRow(), r.bottomRow() + 1)) lines = [] for row in sorted(rows): values = [] for col in range(self.config_table.columnCount()): item = self.config_table.item(row, col) values.append(item.text() if item else "") lines.append("\t".join(values)) QApplication.clipboard().setText("\n".join(lines)) def delete_selected_rows(self): """删除选中行""" if self.use_model_view and self.table_view.selectionModel(): rows = sorted({idx.row() for idx in self.table_view.selectionModel().selectedRows()}, reverse=True) if not rows: return for row in rows: src_index = self.table_proxy.mapToSource(self.table_proxy.index(row, 0)) if src_index.isValid(): self.table_model.removeRows(src_index.row(), 1) self._update_checked_count() return ranges = self.config_table.selectedRanges() if not ranges: return rows = set() for r in ranges: rows.update(range(r.topRow(), r.bottomRow() + 1)) for row in sorted(rows, reverse=True): self.config_table.removeRow(row) if row < len(self.configs): self.configs.pop(row) self.update_table() def export_selected_rows(self, fmt): """导出选中行""" if self.use_model_view: if not self.table_view.selectionModel(): self._show_infobar("warning", "提示", "未选择任何行") return rows = [idx.row() for idx in self.table_view.selectionModel().selectedRows()] if not rows: self._show_infobar("warning", "提示", "未选择任何行") return data = [] headers = [self.table_proxy.headerData(i, Qt.Orientation.Horizontal) for i in range(9)] for row in sorted(set(rows)): row_data = [] for col in range(9): idx = self.table_proxy.index(row, col) row_data.append(str(self.table_proxy.data(idx))) data.append(row_data) df = pd.DataFrame(data, columns=headers) if fmt == "csv": file_path, _ = QFileDialog.getSaveFileName(self, "导出CSV", "selected.csv", "CSV (*.csv)") if not file_path: return df.to_csv(file_path, index=False, encoding="utf-8-sig") self._show_infobar("success", "成功", f"已导出CSV: {file_path}") else: file_path, _ = QFileDialog.getSaveFileName(self, "导出Excel", "selected.xlsx", "Excel (*.xlsx)") if not file_path: return try: df.to_excel(file_path, index=False) self._show_infobar("success", "成功", f"已导出Excel: {file_path}") except Exception as e: self._show_infobar("error", "错误", f"导出失败: {str(e)}") return ranges = self.config_table.selectedRanges() if not ranges: self._show_infobar("warning", "提示", "未选择任何行") return rows = set() for r in ranges: rows.update(range(r.topRow(), r.bottomRow() + 1)) data = [] headers = [self.config_table.horizontalHeaderItem(i).text() for i in range(1, 10)] for row in sorted(rows): if not self.page_row_indices or row >= len(self.page_row_indices): continue config_index = self.page_row_indices[row] row_data = [] for col in range(1, 10): item = self.config_table.item(row, col) row_data.append(item.text() if item else "") data.append(row_data) df = pd.DataFrame(data, columns=headers) if fmt == "csv": file_path, _ = QFileDialog.getSaveFileName(self, "导出CSV", "selected.csv", "CSV (*.csv)") if not file_path: return df.to_csv(file_path, index=False, encoding="utf-8-sig") self._show_infobar("success", "成功", f"已导出CSV: {file_path}") else: file_path, _ = QFileDialog.getSaveFileName(self, "导出Excel", "selected.xlsx", "Excel (*.xlsx)") if not file_path: return try: df.to_excel(file_path, index=False) self._show_infobar("success", "成功", f"已导出Excel: {file_path}") except Exception as e: self._show_infobar("error", "错误", f"导出失败: {str(e)}") def export_all_rows(self): """导出全部数据""" if self.config_table.rowCount() == 0: self._show_infobar("warning", "提示", "没有可导出的数据") return if self.use_model_view and self.table_proxy: total_rows = self.table_proxy.rowCount() headers = [self.table_proxy.headerData(i, Qt.Orientation.Horizontal) for i in range(9)] data = [] for row in range(total_rows): row_data = [] for col in range(9): idx = self.table_proxy.index(row, col) row_data.append(str(self.table_proxy.data(idx))) data.append(row_data) df = pd.DataFrame(data, columns=headers) file_path, selected_filter = QFileDialog.getSaveFileName( self, "导出数据", "all.csv", "CSV (*.csv);;Excel (*.xlsx)" ) if not file_path: return try: if file_path.lower().endswith(".xlsx") or "Excel" in selected_filter: df.to_excel(file_path, index=False) else: df.to_csv(file_path, index=False, encoding="utf-8-sig") self._show_infobar("success", "成功", f"已导出: {file_path}") except Exception as e: self._show_infobar("error", "错误", f"导出失败: {str(e)}") return headers = [self.config_table.horizontalHeaderItem(i).text() for i in range(1, 10)] data = [] for row in range(self.config_table.rowCount()): row_data = [] for col in range(1, 10): item = self.config_table.item(row, col) row_data.append(item.text() if item else "") data.append(row_data) df = pd.DataFrame(data, columns=headers) file_path, selected_filter = QFileDialog.getSaveFileName( self, "导出数据", "all.csv", "CSV (*.csv);;Excel (*.xlsx)" ) if not file_path: return try: if file_path.lower().endswith(".xlsx") or "Excel" in selected_filter: df.to_excel(file_path, index=False) else: df.to_csv(file_path, index=False, encoding="utf-8-sig") self._show_infobar("success", "成功", f"已导出: {file_path}") except Exception as e: self._show_infobar("error", "错误", f"导出失败: {str(e)}") def toggle_nav_compact(self): """切换侧边导航收起/展开""" self.nav_compact = not self.nav_compact if self.nav_compact: self.nav_card.setFixedWidth(60) for btn in self.nav_buttons: btn.setToolTip(btn.text()) btn.setText("") self.nav_toggle_btn.setText("展开") self.nav_title.setVisible(False) self.nav_divider.setVisible(False) self.nav_footer.setVisible(False) else: self.nav_card.setFixedWidth(150) labels = ["工作台", "日志"] for btn, label in zip(self.nav_buttons, labels): btn.setText(label) btn.setToolTip("") self.nav_toggle_btn.setText("收起") self.nav_title.setVisible(True) self.nav_divider.setVisible(True) self.nav_footer.setVisible(True) def filter_table(self, text): """筛选表格行并高亮关键词""" keyword_raw = text.strip() suppress_clear = getattr(self, "_suppress_filter_clear_once", False) if suppress_clear: self._suppress_filter_clear_once = False # 清除状态筛选，确保文本筛选基于全量数据 if hasattr(self, '_current_status_filter') and self._current_status_filter: self._current_status_filter = None self.filtered_config_indices = None if not self.use_model_view and hasattr(self, 'config_table'): for row in range(self.config_table.rowCount()): self.config_table.setRowHidden(row, False) # 如果先全选再进行筛选，先清空勾选，避免隐藏行仍保持勾选 if (not suppress_clear and keyword_raw and hasattr(self, "table_select_all_checkbox") and self.table_select_all_checkbox.isChecked()): for config in self.configs: config['勾选'] = False self.table_select_all_checkbox.blockSignals(True) self.table_select_all_checkbox.setChecked(False) self.table_select_all_checkbox.blockSignals(False) self._update_checked_count() self._update_status_statistics() # 同步当前页勾选框显示 if not self.use_model_view and hasattr(self, "config_table"): for row in range(self.config_table.rowCount()): wrapper = self.config_table.cellWidget(row, 0) if wrapper: checkbox = wrapper.findChild(QCheckBox) if checkbox: checkbox.blockSignals(True) checkbox.setChecked(False) checkbox.blockSignals(False) if self.use_model_view: if not self.table_proxy: return if not keyword_raw: self.table_proxy.setFilterRegularExpression(QRegularExpression()) return terms = [re.escape(t) for t in keyword_raw.split() if t] if not terms: pattern = "" else: pattern = "".join([f"(?=.*{t})" for t in terms]) + ".*" regex = QRegularExpression(pattern, QRegularExpression.CaseInsensitiveOption) column_index = self._filter_model_column_index() self.table_proxy.setFilterKeyColumn(column_index) self.table_proxy.setFilterRegularExpression(regex) return if not self.config_table: return # 表格列与 config 键的对应（列 1~9） _table_config_keys = ('多多id', '序号', '话题', '定时发布', '间隔时间', '达人链接', '执行人', '情况', '文件路径') if not keyword_raw: # 清空筛选：在全量数据上显示，并清除高亮 self.filtered_config_indices = None self.current_page = 1 self.update_table() for row in range(self.config_table.rowCount()): for col in range(self.config_table.columnCount()): item = self.config_table.item(row, col) if item: item.setBackground(self._default_color()) self.config_table.setRowHidden(row, False) self.table_match_rows = [] self.table_match_index = -1 return # 在全量 configs 上计算匹配的配置索引（不限于当前页） terms_raw = [t for t in keyword_raw.split() if t] terms_lower = [t.lower() for t in terms_raw] column_index = self._filter_column_index() matching_indices = [] for i, config in enumerate(self.configs): if column_index >= 1 and column_index <= 9: key = _table_config_keys[column_index - 1] cell_text = str(config.get(key, '')) else: cell_text = ' '.join(str(config.get(k, '')) for k in _table_config_keys) cell_compare = cell_text.lower() if all(term in cell_compare for term in terms_lower): matching_indices.append(i) only_match = self.table_only_match.isChecked() if hasattr(self, 'table_only_match') and self.table_only_match else False if only_match: # 仅显示匹配项：只显示匹配的数据，表格行数=当前页数据行，不出现空行或其它数据 self.filtered_config_indices = matching_indices else: # 显示全部，只做高亮 self.filtered_config_indices = None self.current_page = 1 self.update_table() # 高亮当前页中的匹配单元格（仅显示匹配项时当前页全是匹配行；显示全部时只高亮匹配的格） for row in range(self.config_table.rowCount()): for col in range(self.config_table.columnCount()): if column_index >= 0 and col != column_index: try: item = self.config_table.item(row, col) if item: item.setBackground(self._default_color()) except RuntimeError: pass continue try: item = self.config_table.item(row, col) if item: cell_text = item.text() cell_compare = cell_text.lower() if all(term in cell_compare for term in terms_lower) and self.table_highlight.isChecked(): item.setBackground(self._highlight_color()) else: item.setBackground(self._default_color()) except RuntimeError: continue self.table_match_rows = list(range(self.config_table.rowCount())) self.table_match_index = -1 def next_table_match(self): """跳转到下一条匹配""" if not self.table_match_rows: return if self.table_match_index < 0: self.table_match_index = 0 else: self.table_match_index = (self.table_match_index + 1) % len(self.table_match_rows) row = self.table_match_rows[self.table_match_index] self.config_table.selectRow(row) item = self.config_table.item(row, 0) or self.config_table.item(row, 1) if item: self.config_table.scrollToItem(item) def prev_table_match(self): """跳转到上一条匹配""" if not self.table_match_rows: return if self.table_match_index < 0: self.table_match_index = len(self.table_match_rows) - 1 else: self.table_match_index = (self.table_match_index - 1) % len(self.table_match_rows) row = self.table_match_rows[self.table_match_index] self.config_table.selectRow(row) item = self.config_table.item(row, 0) or self.config_table.item(row, 1) if item: self.config_table.scrollToItem(item) def _apply_schedule_intervals(self, configs_with_indices): """按多多ID应用定时发布+间隔时间规则 configs_with_indices: [{"config_index": config_index, "config": config}, ...] """ from collections import defaultdict grouped = defaultdict(list) for item in configs_with_indices: config = item["config"] user_id = config.get("多多id", "") if not user_id: continue grouped[user_id].append(item) updated_count = 0 for user_id, items in grouped.items(): # 按原始配置列表中的顺序处理 items.sort(key=lambda x: x["config_index"]) base_time = None # 上一条的发布时间（基准时间） for entry in items: config = entry["config"] config_index = entry["config_index"] schedule_text = (config.get("定时发布") or "").strip() interval_value = config.get("间隔时间", 0) # 解析间隔时间（分钟转秒） current_interval = self._parse_interval_seconds(interval_value) # 解析定时时间 parsed_time = self._parse_schedule_time(schedule_text) if schedule_text else None # 情况1：当前条目有定时时间 -> 使用该定时时间，并记录为基准时间 if parsed_time: base_time = parsed_time # 情况2：当前条目没有定时时间，但有间隔时间 elif not parsed_time and current_interval > 0: if base_time: # 有基准时间 -> 新时间 = 基准时间 + 间隔时间 base_time = base_time + timedelta(seconds=current_interval) new_text = self._format_schedule_time(base_time) # 更新配置和表格单元格（如果可见） self._update_table_cell(config_index, 4, new_text, highlight=True, is_config_index=True) updated_count += 1 return updated_count @staticmethod def _parse_schedule_time(text): """解析定时发布时间字符串""" if not text: return None try: dt = pd.to_datetime(text, errors="coerce") if pd.isna(dt): return None return dt.to_pydatetime() except (ValueError, TypeError, AttributeError): return None def _is_schedule_time_expired(self, time_start): """检查定时发布时间是否已过期（早于当前时间） Args: time_start: 定时发布时间字符串，如 "2026-01-15 09:30:00" Returns: bool: 如果时间已过期返回True，否则返回False。如果时间为空或无法解析，返回False（不跳过） """ if not time_start: return False try: # 解析时间字符串 schedule_dt = self._parse_schedule_time(time_start) if not schedule_dt: return False # 与当前时间比较 now = datetime.now() if schedule_dt < now: return True return False except (ValueError, TypeError, AttributeError) as e: logger.warning(f"检查定时发布时间是否过期时出错: {e}") return False @staticmethod def _parse_interval_seconds(interval_value): """解析间隔时间（默认按分钟），支持秒/分钟/小时（如: 30, 10m, 2h, 10分钟, 2小时） 注意：纯数字默认按分钟；空字符串或None返回0，表示没有间隔时间 """ if interval_value is None or interval_value == '': return 0 value_str = str(interval_value).strip().lower() if not value_str: return 0 # 中文单位映射 cn_map = { "秒": "s", "分钟": "m", "分": "m", "小时": "h", "时": "h" } for cn, en in cn_map.items(): if value_str.endswith(cn): value_str = value_str[:-len(cn)] + en break try: # 纯数字，默认分钟 if value_str.isdigit(): return int(value_str) * 60 # 支持 10m / 2h / 30s unit = value_str[-1] num_part = value_str[:-1].strip() if not num_part: return 0 num = float(num_part) if unit == "m": return int(num * 60) if unit == "h": return int(num * 3600) if unit == "s": return int(num) except (ValueError, TypeError): return 0 return 0 @staticmethod def _format_schedule_time(dt): """格式化定时发布时间字符串""" if not dt: return "" return dt.strftime("%Y-%m-%d %H:%M:%S") def _update_table_cell(self, index, col, value, highlight=False, is_config_index=False): """更新配置数据及其对应的表格单元格（如果当前可见） index: 行号 (is_config_index=False) 或 配置列表索引 (is_config_index=True) """ try: # 1. 确定配置索引和表格行号 if is_config_index: config_index = index row_idx = self.page_row_indices.index(config_index) if hasattr(self, 'page_row_indices') and config_index in self.page_row_indices else -1 else: row_idx = index config_index = self.page_row_indices[row_idx] if hasattr(self, 'page_row_indices') and row_idx < len(self.page_row_indices) else row_idx # 2. 更新数据源 self.configs if 0 <= config_index < len(self.configs): col_to_field = { 4: "定时发布", 8: "情况", 9: "文件路径", } field = col_to_field.get(col) if field: self.configs[config_index][field] = str(value) # 3. 如果行可见，更新 UI if 0 <= row_idx < self.config_table.rowCount(): # 使用 blockSignals 临时阻止信号，防止递归 self.config_table.blockSignals(True) try: item = QTableWidgetItem(str(value)) item.setTextAlignment(Qt.AlignmentFlag.AlignCenter) item.setFlags(item.flags() & ~Qt.ItemFlag.ItemIsEditable) if highlight: item.setBackground(QColor("#E6F4FF")) self.config_table.setItem(row_idx, col, item) finally: self.config_table.blockSignals(False) except Exception as e: logger.warning(f"更新单元格失败: {e}") self.config_table.blockSignals(False) def _update_table_status(self, index, status, is_config_index=False): """更新状态列及其对应的表格单元格 index: 行号 (is_config_index=False) 或 配置列表索引 (is_config_index=True) """ try: # 1. 确定配置索引和表格行号 if is_config_index: config_index = index row_idx = self.page_row_indices.index(config_index) if hasattr(self, 'page_row_indices') and config_index in self.page_row_indices else -1 else: row_idx = index config_index = self.page_row_indices[row_idx] if hasattr(self, 'page_row_indices') and row_idx < len(self.page_row_indices) else row_idx # 2. 更新数据源 if 0 <= config_index < len(self.configs): self.configs[config_index]["情况"] = status # 3. 如果可见，更新 UI if 0 <= row_idx < self.config_table.rowCount(): # 使用 blockSignals 临时阻止信号，防止递归 self.config_table.blockSignals(True) try: # 第8列是"情况"列，只设置文字颜色，不设置背景色和图标 status_item = QTableWidgetItem(status) status_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter) status_item.setFlags(status_item.flags() & ~Qt.ItemFlag.ItemIsEditable) if status == "已完成": status_item.setForeground(QColor("#155724")) # 绿色 elif status == "失败": status_item.setForeground(QColor("#721C24")) # 红色 elif status == "执行中": status_item.setForeground(QColor("#0C5460")) # 蓝色 self._apply_current_highlight_to_item(row_idx, 8, status_item, status) self.config_table.setItem(row_idx, 8, status_item) finally: self.config_table.blockSignals(False) except Exception as e: logger.error(f"更新状态失败: {e}") self.config_table.blockSignals(False) @staticmethod def _highlight_color(): """高亮颜色 - 淡蓝色背景""" return QColor(173, 216, 230) # 淡蓝色 (Light Blue) def _default_color(self): """默认背景色""" return self.config_table.palette().color(self.config_table.palette().Base) def _apply_current_highlight_to_item(self, _row, col, item, text=None): """根据当前筛选条件对单元格应用高亮""" if not item or not hasattr(self, "table_search_input"): return if not self.table_highlight.isChecked(): return keyword_raw = self.table_search_input.text().strip() if not keyword_raw: return column_index = self._filter_column_index() if column_index >= 0 and col != column_index: return terms = [t.lower() for t in keyword_raw.split() if t] if not terms: return cell_text = text if text is not None else item.text() cell_compare = (cell_text or "").lower() if all(term in cell_compare for term in terms): item.setBackground(self._highlight_color()) else: item.setBackground(self._default_color()) def _filter_column_index(self): """筛选项下拉对应的表格列索引；-1 表示全部列。排除情况列，以多多ID等为筛选项。""" i = self.table_column_filter.currentIndex() if i <= 0 or not getattr(self, "_filter_table_columns", None): return -1 k = i - 1 if k >= len(self._filter_table_columns): return -1 return self._filter_table_columns[k] def _filter_model_column_index(self): """Model/View 模式下筛选项对应的列索引；-1 表示全部列。""" i = self.table_column_filter.currentIndex() if i <= 0 or not getattr(self, "_filter_model_columns", None): return -1 k = i - 1 if k >= len(self._filter_model_columns): return -1 return self._filter_model_columns[k] def _show_all_rows(self): """显示全部行""" for row in range(self.config_table.rowCount()): self.config_table.setRowHidden(row, False) def _filter_by_status(self, status): """按状态筛选表格行（在全量数据上计算，分页显示筛选结果）""" if not getattr(self, 'configs', None) or not self.configs: self._show_infobar("warning", "提示", "暂无数据") return # 清除文本筛选，确保每次筛选都基于全量数据 if hasattr(self, 'table_search_input') and self.table_search_input.text().strip(): self.table_search_input.blockSignals(True) self.table_search_input.clear() self.table_search_input.blockSignals(False) self.filtered_config_indices = None self.table_match_rows = [] self.table_match_index = -1 # 切换筛选状态 current_filter = getattr(self, '_current_status_filter', None) if current_filter == status: self._current_status_filter = None self.filtered_config_indices = None self.current_page = 1 self.update_table() self._show_infobar("success", "提示", "已显示全部记录") return self._current_status_filter = status # 在全量 configs 上计算匹配的配置索引 matching_indices = [] for i, config in enumerate(self.configs): config_status = str(config.get('情况', '')) if status == "成功": match = "完成" in config_status or "成功" in config_status elif status == "失败": match = "失败" in config_status or "错误" in config_status else: match = status in config_status if match: matching_indices.append(i) self.filtered_config_indices = matching_indices self.current_page = 1 self.update_table() if not matching_indices: self._show_infobar("warning", "提示", f"没有{status}的记录") else: self._show_infobar("success", "筛选", f"已筛选出 {len(matching_indices)} 条{status}记录，再次点击取消筛选") def _update_status_statistics(self): """更新状态统计（成功/失败/待执行数量）- 统计所有配置的真实状态 待执行：勾选的且状态不是"已完成"的数据，表示用户选择要处理的任务数 执行中：只有在任务运行时才有值，任务完成后为0 成功：状态为"已完成"的数据数量 失败：状态为"失败/跳过/过期"的数据数量 """ if not hasattr(self, 'configs') or not self.configs: self.set_status_cards(pending=0, running=0, success=0, failed=0) return pending_count = 0 success_count = 0 failed_count = 0 # 统计所有配置的状态（根据数据总量来统计） for config in self.configs: status = config.get('情况', '待执行') is_checked = config.get('勾选', False) if "完成" in status or "成功" in status: success_count += 1 elif "失败" in status or "错误" in status or "过期" in status or "跳过" in status: failed_count += 1 # 只有勾选的失败项才算待执行 if is_checked: pending_count += 1 elif "待" in status or not status: # 只有勾选的待执行项才算待执行 if is_checked: pending_count += 1 # 执行中始终为0（只有任务运行时才会被单独更新） self.set_status_cards(pending=pending_count, running=0, success=success_count, failed=failed_count) def retry_failed_items(self): """重新发布所有失败的项目""" if not hasattr(self, 'configs') or not self.configs: self._show_infobar("warning", "提示", "暂无数据") return # 收集失败的项目索引 failed_indices = [] for idx, config in enumerate(self.configs): status = config.get('情况', '') if "失败" in status or "错误" in status or "过期" in status or "跳过" in status: failed_indices.append(idx) if not failed_indices: self._show_infobar("warning", "提示", "没有失败的项目需要重新发布") return # 确认对话框 reply = QMessageBox.question( self, "确认重新发布", f"发现 {len(failed_indices)} 条失败记录，是否重新发布？\n\n" "重新发布将把这些记录的状态重置为【待执行】，然后执行发布任务。", QMessageBox.Yes | QMessageBox.No, QMessageBox.No ) if reply != QMessageBox.Yes: return # 重置失败项的状态为"待执行" for idx in failed_indices: self.configs[idx]['情况'] = '待执行' # 更新表格显示 self.update_table() self._update_status_statistics() # 筛选显示这些待重新发布的项 self._filter_by_status("待执行") self._show_infobar("success", "已重置", f"已将 {len(failed_indices)} 条失败记录重置为待执行状态，请点击【开始上传】按钮开始发布") def get_failed_configs(self): """获取所有失败的配置项""" if not hasattr(self, 'configs') or not self.configs: return [] failed_configs = [] for config in self.configs: status = config.get('情况', '') if "失败" in status or "错误" in status or "过期" in status or "跳过" in status: failed_configs.append(config) return failed_configs def set_status_cards(self, update_text=None, pending=None, running=None, success=None, failed=None): """更新状态卡片显示""" if update_text is not None: self.status_update_value.setText(update_text) if "未找到" in update_text: self.status_update_value.setStyleSheet("color: #b42318;") elif "未更新" in update_text: self.status_update_value.setStyleSheet("color: #6b7280;") else: self.status_update_value.setStyleSheet("color: #1d4ed8;") if pending is not None: self.status_pending_value.setText(str(pending)) try: pending_num = int(str(pending)) except ValueError: pending_num = 0 if pending_num > 0: self.status_pending_value.setStyleSheet("color: #b45309;") else: self.status_pending_value.setStyleSheet("color: #15803d;") if running is not None: self.status_running_value.setText(str(running)) running_text = str(running) if running_text in ["0", "0/0"]: self.status_running_value.setStyleSheet("color: #6b7280;") else: self.status_running_value.setStyleSheet("color: #1d4ed8;") if success is not None: self.status_success_value.setText(str(success)) try: success_num = int(str(success)) except ValueError: success_num = 0 if success_num > 0: self.status_success_value.setStyleSheet("color: #15803d; font-weight: bold;") else: self.status_success_value.setStyleSheet("color: #6b7280;") if failed is not None: self.status_failed_value.setText(str(failed)) try: failed_num = int(str(failed)) except ValueError: failed_num = 0 if failed_num > 0: self.status_failed_value.setStyleSheet("color: #dc2626; font-weight: bold;") else: self.status_failed_value.setStyleSheet("color: #6b7280;") def set_running_progress(self, done, total): """更新执行中统计""" self.running_done = done self.running_total = total if total > 0: self.set_status_cards(running=f"{done}/{total}") if hasattr(self, "status_running_progress"): percent = int((done / total) * 100) self.status_running_progress.setValue(percent) else: self.set_status_cards(running="0") if hasattr(self, "status_running_progress"): self.status_running_progress.setValue(0) def clear_log(self): """清空日志显示""" self.log_text.clear() def filter_log(self, text): """过滤日志内容""" keyword = text.strip() self._clear_log_highlight() self._update_log_match_status(0) if not keyword: return self._update_log_matches(keyword) if self.log_highlight_check.isChecked(): self._highlight_log_matches() self.find_log(backward=False, reset=True) def export_log(self): """导出日志到文件""" log_content = self.log_text.toPlainText() if not log_content.strip(): self._show_infobar("warning", "提示", "日志为空，无法导出") return file_path, _ = QFileDialog.getSaveFileName( self, "保存日志", "log.txt", "文本文件 (*.txt)" ) if not file_path: return try: with open(file_path, "w", encoding="utf-8") as f: f.write(log_content) self._show_infobar("success", "成功", f"日志已导出: {file_path}") except Exception as e: self._show_infobar("error", "错误", f"导出失败: {str(e)}") def find_log(self, backward=False, reset=False): """查找日志""" keyword = self.log_search_input.text().strip() if not keyword: return if not self.log_match_positions: self._update_log_matches(keyword) if not self.log_match_positions: return if reset: self.log_match_index = 0 if not backward else len(self.log_match_positions) - 1 else: step = -1 if backward else 1 self.log_match_index = (self.log_match_index + step) % len(self.log_match_positions) start, end = self.log_match_positions[self.log_match_index] cursor = self.log_text.textCursor() cursor.setPosition(start) cursor.setPosition(end, QTextCursor.KeepAnchor) self.log_text.setTextCursor(cursor) self.log_text.ensureCursorVisible() def _clear_log_highlight(self): """清除日志高亮""" cursor = self.log_text.textCursor() cursor.select(cursor.Document) cursor.setCharFormat(self.log_text.currentCharFormat()) cursor.clearSelection() def _highlight_log_matches(self): """高亮日志所有匹配项""" if not self.log_match_positions: return fmt = self.log_text.currentCharFormat() fmt.setBackground(self.log_text.palette().color(self.log_text.palette().Highlight).lighter(160)) for start, end in self.log_match_positions: cursor = self.log_text.textCursor() cursor.setPosition(start) cursor.setPosition(end, QTextCursor.KeepAnchor) cursor.mergeCharFormat(fmt) def _update_log_matches(self, keyword): """更新日志匹配位置""" self.log_match_positions = [] self.log_match_index = -1 if not keyword: self._update_log_match_status(0) return content = self.log_text.toPlainText() whole_word = self.log_whole_word.isChecked() pattern_text = re.escape(keyword) if whole_word: pattern_text = rf"\b{pattern_text}\b" pattern = re.compile(pattern_text, re.IGNORECASE) for match in pattern.finditer(content): self.log_match_positions.append((match.start(), match.end())) self._update_log_match_status(len(self.log_match_positions)) def _update_log_match_status(self, count): """更新日志匹配统计""" if hasattr(self, "log_match_status"): self.log_match_status.setText(f"匹配: {count}") def _apply_table_column_widths(self): """应用配置表列宽（仅按窗口宽度自适应，不根据内容变化）""" header = self.config_table.horizontalHeader() header.setStretchLastSection(True) # 禁用根据内容自适应，防止导入或更新数据时列宽剧烈跳动 # 设置最小列宽，确保内容可见 min_widths = { 0: 50, # 勾选框 1: 80, # 多多ID 2: 60, # 序号 3: 100, # 话题 4: 100, # 定时发布 5: 80, # 间隔时间 6: 120, # 达人链接 7: 80, # 执行人 8: 80, # 情况 9: 150, # 文件路径 10: 70, # 进度 11: 100 # 操作 } # 切换到Interactive模式，允许手动拖拽调整 header.setSectionResizeMode(0, QHeaderView.Fixed) # 勾选框固定 for col in range(1, self.config_table.columnCount()): header.setSectionResizeMode(col, QHeaderView.Interactive) if col in min_widths: # 仅在第一次或比例未建立时设置初始宽度 if not self._column_width_ratios: self.config_table.setColumnWidth(col, min_widths[col]) # 如果已经有保存的比例，直接按比例缩放 if self._column_width_ratios: self._auto_resize_table_columns() else: # 第一次加载，根据当前设置的初始宽度计算比例 self._update_column_width_ratios() self._auto_resize_table_columns() def _update_column_width_ratios(self): """更新列宽比例""" if self.config_table.columnCount() == 0: return total_width = 0 widths = {} # 计算所有列的总宽度（不包括勾选框） for col in range(1, self.config_table.columnCount()): width = self.config_table.columnWidth(col) widths[col] = width total_width += width # 计算比例 if total_width > 0: self._column_width_ratios = {} for col, width in widths.items(): self._column_width_ratios[col] = width / total_width def _auto_resize_table_columns(self): """根据比例自动调整表格列宽""" if not self._column_width_ratios or self._is_manual_resize: return header = self.config_table.horizontalHeader() if header.sectionResizeMode(1) != QHeaderView.Interactive: return # 获取表格可用宽度 table_width = self.config_table.viewport().width() checkbox_width = self.config_table.columnWidth(0) if self.config_table.columnCount() > 0 else 0 available_width = table_width - checkbox_width if available_width <= 0: return # 按比例分配宽度 self._is_manual_resize = True # 临时标记，避免触发信号 columns = sorted(self._column_width_ratios.keys()) assigned_width = 0 for i, col in enumerate(columns): if col < self.config_table.columnCount(): ratio = self._column_width_ratios[col] # 最后一列取剩余所有宽度，确保填满 if i == len(columns) - 1: new_width = max(60, available_width - assigned_width) else: new_width = int(available_width * ratio) min_width = 60 if new_width < min_width: new_width = min_width self.config_table.setColumnWidth(col, new_width) assigned_width += new_width self._is_manual_resize = False def on_column_resized(self, logical_index, _old_size, _new_size): """列宽调整时的回调（手动或自动）""" if not self._is_manual_resize and logical_index > 0 and self._resize_timer is not None: # 用户手动调整了列宽，延迟更新比例（避免拖拽时频繁更新） self._resize_timer.stop() self._resize_timer.start(300) # 300ms后更新比例 def _delayed_update_ratios(self): """延迟更新列宽比例""" if not self._is_manual_resize: self._update_column_width_ratios() def on_table_geometry_changed(self): """表格几何形状改变时的回调（窗口大小改变）""" if not self._is_manual_resize and self._auto_resize_timer is not None: # 使用独立的定时器进行防抖，避免频繁触发导致卡顿 self._auto_resize_timer.stop() self._auto_resize_timer.start(50) def _apply_table_view_column_widths(self): """应用 Model/View 列宽（仅按窗口宽度自适应，不根据内容变化）""" if not self.table_view.model(): return header = self.table_view.horizontalHeader() header.setStretchLastSection(True) # 禁用根据内容自适应 min_widths = { 0: 80, # 多多ID 1: 60, # 序号 2: 100, # 话题 3: 100, # 定时发布 4: 80, # 间隔时间 5: 120, # 达人链接 6: 80, # 执行人 7: 80, # 情况 8: 150, # 文件路径 9: 70, # 进度 10: 100 # 操作 } # 切换到Interactive模式 for col in range(self.table_view.model().columnCount()): header.setSectionResizeMode(col, QHeaderView.Interactive) if col in min_widths and not self._table_view_column_width_ratios: self.table_view.setColumnWidth(col, min_widths[col]) # 按比例分配或初始化比例 if self._table_view_column_width_ratios: self._auto_resize_table_view_columns() else: self._update_table_view_column_width_ratios() self._auto_resize_table_view_columns() def _update_table_view_column_width_ratios(self): """更新Model/View模式的列宽比例""" if not self.table_view.model() or self.table_view.model().columnCount() == 0: return total_width = 0 widths = {} # 计算所有列的总宽度 for col in range(self.table_view.model().columnCount()): width = self.table_view.columnWidth(col) widths[col] = width total_width += width # 计算比例 if total_width > 0: self._table_view_column_width_ratios = {} for col, width in widths.items(): self._table_view_column_width_ratios[col] = width / total_width def _auto_resize_table_view_columns(self): """根据比例自动调整Model/View表格列宽""" if not self._table_view_column_width_ratios or self._is_table_view_manual_resize: return header = self.table_view.horizontalHeader() if not header or header.sectionResizeMode(0) != QHeaderView.Interactive: return # 获取表格可用宽度 table_width = self.table_view.viewport().width() if table_width <= 0: return # 按比例分配宽度 self._is_table_view_manual_resize = True # 临时标记，避免触发信号 columns = sorted(self._table_view_column_width_ratios.keys()) assigned_width = 0 for i, col in enumerate(columns): if col < self.table_view.model().columnCount(): ratio = self._table_view_column_width_ratios[col] # 最后一列取剩余所有宽度，确保填满 if i == len(columns) - 1: new_width = max(60, table_width - assigned_width) else: new_width = int(table_width * ratio) min_width = 60 if new_width < min_width: new_width = min_width self.table_view.setColumnWidth(col, new_width) assigned_width += new_width self._is_table_view_manual_resize = False def on_table_view_column_resized(self, _logical_index, _old_size, _new_size): """Model/View模式列宽调整时的回调（手动或自动）""" if not self._is_table_view_manual_resize and self._table_view_resize_timer is not None: # 用户手动调整了列宽，延迟更新比例（避免拖拽时频繁更新） self._table_view_resize_timer.stop() self._table_view_resize_timer.start(300) # 300ms后更新比例 def _delayed_update_table_view_ratios(self): """延迟更新Model/View模式的列宽比例""" if not self._is_table_view_manual_resize: self._update_table_view_column_width_ratios() def on_table_view_geometry_changed(self): """Model/View模式表格几何形状改变时的回调（窗口大小改变）""" if not self._is_table_view_manual_resize and self._auto_resize_table_view_timer is not None: # 使用独立的定时器进行防抖，避免频繁触发导致卡顿 self._auto_resize_table_view_timer.stop() self._auto_resize_table_view_timer.start(50) # noinspection SpellCheckingInspection def _show_infobar(self, level, title, content): """显示提示条""" # noinspection PyArgumentList if level == "success": InfoBar.success(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT) elif level == "warning": # noinspection PyArgumentList InfoBar.warning(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT) elif level == "info": # noinspection PyArgumentList InfoBar.info(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT) else: # noinspection PyArgumentList InfoBar.error(title=title, content=content, parent=self, position=InfoBarPosition.TOP_RIGHT) def browse_folder(self): """浏览文件夹""" folder_path = QFileDialog.getExistingDirectory(self, "选择文件夹") if folder_path: self.folder_path_input.setText(folder_path) def download_excel_template(self): """下载Excel配置模板""" try: # 选择保存路径 file_path, _ = QFileDialog.getSaveFileName( self, "保存配置模板", "配置模板.xlsx", "Excel文件 (*.xlsx)" ) if not file_path: return # 创建模板数据 template_data = { '多多id': ['示例ID_001', '示例ID_001', '示例ID_002'], '序号': ['1', '2', '1'], '话题': ['#话题1', '#话题2', '#话题1'], '定时发布': ['2024-01-01 10:00', '', ''], '间隔时间': [5, 5, 0], '达人链接': ['https://example.com/user1', '', 'https://example.com/user2'], '执行人': ['张三', '张三', '李四'], '情况': ['待执行', '待执行', '待执行'] } df = pd.DataFrame(template_data) # 保存Excel文件 df.to_excel(file_path, index=False, engine='openpyxl') self._show_infobar("success", "成功", f"模板已保存: {file_path}") self.log_text.append(f"配置模板已下载: {file_path}") self.log_text.append("模板说明:") self.log_text.append(" - 多多id: 用户ID，相同ID的数据会按序号顺序处理") self.log_text.append(" - 序号: 文件序号，用于匹配文件夹中的文件（如：1-视频名称.mp4）") self.log_text.append(" - 话题: 发布时的话题标签") self.log_text.append(" - 定时发布: 定时发布时间（格式：yyyy-MM-dd HH:mm）") self.log_text.append(" - 间隔时间: 在上一条基础上延迟的分钟数（无定时时间时生效）") self.log_text.append(" - 达人链接: 达人主页链接") self.log_text.append(" - 执行人: 负责人") self.log_text.append(" - 情况: 执行状态（待执行/执行中/已完成/失败）") except Exception as e: self._show_infobar("error", "错误", f"保存模板失败: {str(e)}") logger.error(f"保存模板失败: {e}") def import_excel(self): """导入Excel配置文件（直接弹出文件选择对话框）""" # 弹出文件选择对话框 excel_path, _ = QFileDialog.getOpenFileName( self, "选择Excel配置文件", "", "Excel文件 (*.xlsx *.xls)" ) if not excel_path: return # 用户取消选择 # 显示选择的文件路径 self.excel_path_input.setText(excel_path) try: # 读取Excel文件，添加更多异常处理 try: df = pd.read_excel(excel_path) except FileNotFoundError: self._show_infobar("error", "错误", f"找不到文件: {excel_path}") logger.error(f"文件不存在: {excel_path}") return except PermissionError: self._show_infobar("error", "错误", f"文件被占用，请关闭Excel文件后重试") logger.error(f"文件被占用: {excel_path}") return except Exception as e: self._show_infobar("error", "错误", f"读取Excel文件失败: {str(e)}") logger.error(f"读取Excel失败: {e}") return if df.empty: self._show_infobar("warning", "警告", "Excel文件为空") return # 检查必需的列 required_columns = ['多多id', '序号', '话题', '定时发布', '间隔时间', '达人链接', '执行人', '情况'] missing_columns = [col for col in required_columns if col not in df.columns] if missing_columns: self._show_infobar( "warning", "警告", f"Excel缺少列: {', '.join(missing_columns)}" ) return # 清空所有状态，根据新的Excel配置表格为准（完全重置，不保留任何上一次的数据） # 1. 清空配置列表 self.configs = [] # 2. 重置运行状态变量 self.running_total = 0 self.running_done = 0 # 3. 清空批量任务队列 self.batch_task_queue = [] self.current_batch_task_index = 0 # 4. 清空行映射（用于状态回写） self._row_map_by_user_index = {} # 5. 重置所有计数变量（确保导入新Excel时完全清空上一次的统计） self.batch_success_count = 0 self.batch_failed_count = 0 self.batch_total_tasks = 0 self.batch_processed = 0 self.batch_pending_tasks = 0 # 6. 重置所有状态卡片显示（全部归零） self.set_status_cards(update_text="未更新", pending=0, running=0, success=0, failed=0) # 7. 重置进度条 if hasattr(self, "status_running_progress"): self.status_running_progress.setValue(0) if hasattr(self, "progress_bar"): self.progress_bar.setValue(0) self.progress_bar.setVisible(False) # 8. 重置“更新数据”提示文本 if hasattr(self, "update_status_label"): self.update_status_label.setText("未更新") self.update_status_label.setStyleSheet("color: #666; font-size: 10px;") # 转换为配置列表，添加异常处理 for idx, row in df.iterrows(): try: # 处理间隔时间：保持原始状态，空值保持为空字符串 interval_raw = row.get('间隔时间') if pd.notna(interval_raw) and str(interval_raw).strip() != '': try: interval_value = int(float(interval_raw)) # 先转float再转int，处理小数情况 except (ValueError, TypeError): interval_value = '' # 无效值保持为空 else: interval_value = '' # 空值保持为空 # 辅助函数：将可能带.0的数字字符串转为整数型字符串 def clean_str(val): if pd.isna(val): return '' s = str(val).strip() if s.endswith('.0'): return s[:-2] return s # 导入新Excel时，强制将所有状态重置为"待执行"，根据新的Excel配置表格为准 # 忽略Excel中"情况"列的旧状态值，统一重置为"待执行" status_value = '待执行' config = { '勾选': False, # 导入后默认不勾选，交由用户选择 '多多id': clean_str(row.get('多多id', '')), '序号': clean_str(row.get('序号', '')), '话题': str(row.get('话题', '')).strip() if pd.notna(row.get('话题')) else '', '定时发布': str(row.get('定时发布', '')).strip() if pd.notna(row.get('定时发布')) else '', '间隔时间': interval_value, '达人链接': str(row.get('达人链接', '')).strip() if pd.notna(row.get('达人链接')) else '', '执行人': str(row.get('执行人', '')).strip() if pd.notna(row.get('执行人')) else '', '情况': status_value, # 强制重置为"待执行"，根据新的Excel配置表格为准 '文件路径': '' # 文件路径字段初始为空，通过更新数据按钮填充 } self.configs.append(config) except Exception as e: logger.warning(f"处理第 {idx + 1} 行数据时出错: {e}") continue # 跳过有问题的行 if not self.configs: self._show_infobar("warning", "警告", "未能解析出任何有效配置") return # 清除排序状态，保持Excel原始顺序 self.table_sort_keys = [] self.config_table.horizontalHeader().setSortIndicator(-1, Qt.SortOrder.AscendingOrder) # 更新表格显示（跳过表格->configs同步，避免旧数据回写） try: self.update_table(skip_sync=True) except Exception as e: self._show_infobar("error", "错误", f"更新表格失败: {str(e)}") logger.error(f"更新表格失败: {e}") return # 导入后默认不勾选，确保全选状态为未选中 if hasattr(self, "table_select_all_checkbox"): self.table_select_all_checkbox.blockSignals(True) self.table_select_all_checkbox.setChecked(False) self.table_select_all_checkbox.blockSignals(False) # 显示表格 self.table_group.setVisible(True) # 更新状态统计（基于新导入的配置重新计算） self._update_status_statistics() # 确保更新状态显示为"未更新"（文件路径还未更新） self.set_status_cards(update_text="未更新") self._show_infobar("success", "成功", f"成功导入 {len(self.configs)} 条配置，所有状态已清空重置") except Exception as e: error_msg = f"导入Excel文件失败: {str(e)}" self._show_infobar("error", "错误", error_msg) logger.error(f"导入Excel失败: {e}", exc_info=True) def add_single_config(self): """添加单条配置到配置列表""" try: # 获取输入框的值 user_id = self.add_user_id_input.text().strip() index = self.add_index_input.text().strip() topic = self.add_topic_input.text().strip() schedule = self.add_schedule_input.text().strip() interval_text = self.add_interval_input.text().strip() expert_link = self.add_expert_link_input.text().strip() executor = self.add_executor_input.text().strip() # 验证必填字段 if not user_id: self._show_infobar("warning", "警告", "请输入多多ID") self.add_user_id_input.setFocus() return if not index: self._show_infobar("warning", "警告", "请输入序号") self.add_index_input.setFocus() return # 处理间隔时间 interval_value = '' if interval_text: try: interval_value = int(float(interval_text)) except ValueError: self._show_infobar("warning", "警告", "间隔时间必须是数字") self.add_interval_input.setFocus() return # 创建配置对象 config = { '勾选': False, '多多id': user_id, '序号': index, '话题': topic, '定时发布': schedule, '间隔时间': interval_value, '达人链接': expert_link, '执行人': executor, '情况': '待执行', '文件路径': '' } # 添加到配置列表 self.configs.append(config) # 更新表格显示 self.update_table() # 显示表格 self.table_group.setVisible(True) # 更新状态统计 self._update_status_statistics() self.set_status_cards(update_text="未更新") # 清空输入框 self.clear_add_config_inputs() self._show_infobar("success", "成功", f"已添加配置: {user_id} - {index}") except Exception as e: error_msg = f"添加配置失败: {str(e)}" self._show_infobar("error", "错误", error_msg) logger.error(f"添加配置失败: {e}", exc_info=True) def clear_add_config_inputs(self): """清空单条配置输入框""" self.add_user_id_input.clear() self.add_index_input.clear() self.add_topic_input.clear() self.add_schedule_input.clear() self.add_interval_input.clear() self.add_expert_link_input.clear() self.add_executor_input.clear() # 设置焦点到第一个输入框 self.add_user_id_input.setFocus() def update_table(self, skip_sync=False): """更新配置表格。skip_sync=True 时跳过 表格→configs 同步（如刚由更新数据写入 configs 后刷新表格）。""" if getattr(self, "config_table", None) is None: return if not self.use_model_view and not skip_sync: self._sync_configs_from_table() self.is_updating_table = True # 使用筛选后的索引或全部索引进行分页（筛选在全量数据上计算，分页只切当前页） effective_indices = self.filtered_config_indices if getattr(self, 'filtered_config_indices', None) is not None else list(range(len(self.configs))) total_rows = len(effective_indices) # 设置最小显示行数，即使没有数据也显示空行 min_display_rows = 15 # 最少显示15行 if len(self.configs) > 1000: self._setup_model_view() self.is_updating_table = False return self.use_model_view = False if getattr(self, "table_view", None) is not None: self.table_view.setVisible(False) self.config_table.setVisible(True) for btn in [getattr(self, "page_first_btn", None), getattr(self, "page_prev_btn", None), getattr(self, "page_next_btn", None), getattr(self, "page_last_btn", None), getattr(self, "page_size_combo", None)]: if btn is not None: btn.setEnabled(True) total_pages = max(1, (total_rows + self.page_size - 1) // self.page_size) if self.current_page > total_pages: self.current_page = total_pages start = (self.current_page - 1) * self.page_size end = min(start + self.page_size, total_rows) self.page_row_indices = list(effective_indices[start:end]) # 临时禁用排序，防止填充数据时自动排序打乱顺序 self.config_table.setSortingEnabled(False) # 筛选时只显示当前页数据行，不预留空行，避免“仅显示匹配项”时仍看到多余行 is_filtered = getattr(self, 'filtered_config_indices', None) is not None display_rows = len(self.page_row_indices) if is_filtered else max(len(self.page_row_indices), min_display_rows) self.config_table.setRowCount(display_rows) # 先统一设置行高，再填数据，避免后设行高导致勾选框列布局重算、出现“除第一行外往下移” default_row_height = self.config_table.verticalHeader().defaultSectionSize() for row in range(display_rows): self.config_table.setRowHeight(row, default_row_height) # 先清除第 0 列所有单元格控件，避免连续刷新时旧勾选框残留导致错位 for row in range(display_rows): self.config_table.removeCellWidget(row, 0) # 填充期间禁止表格重绘，避免中间布局导致勾选框错位 self.config_table.setUpdatesEnabled(False) try: # 填充数据行 for table_row, config_index in enumerate(self.page_row_indices): config = self.configs[config_index] # 第0列：勾选框（传入行高，固定高度+居中对齐，避免第一页第二行等错位） self._set_checkbox_item(table_row, config_index, default_row_height) # 其他列的索引均+1 self.config_table.setItem(table_row, 1, self._create_centered_item(str(config.get('多多id', '')))) self.config_table.setItem(table_row, 2, self._create_centered_item(str(config.get('序号', '')))) self.config_table.setItem(table_row, 3, self._create_centered_item(str(config.get('话题', '')))) self.config_table.setItem(table_row, 4, self._create_centered_item(str(config.get('定时发布', '')))) # 间隔时间：保持原始状态，空值显示为空 interval_val = config.get('间隔时间', '') if interval_val == '' or interval_val is None: interval_display = '' else: interval_display = str(interval_val) self.config_table.setItem(table_row, 5, self._create_centered_item(interval_display)) url_text = str(config.get('达人链接', '')) url_item = self._create_centered_item(url_text) url_item.setToolTip(url_text) self.config_table.setItem(table_row, 6, url_item) self.config_table.setItem(table_row, 7, self._create_centered_item(str(config.get('执行人', '')))) self._set_status_item(table_row, str(config.get('情况', '待执行'))) file_path = str(config.get('文件路径', '')) file_path_item = self._create_centered_item(file_path) file_path_item.setToolTip(file_path) self.config_table.setItem(table_row, 9, file_path_item) self._set_progress_item(table_row, str(config.get('情况', '待执行'))) self._set_action_buttons(table_row, config_index) finally: self.config_table.setUpdatesEnabled(True) # 强制表格立即完成布局，避免第一页第二行等勾选框错位 self.config_table.doItemsLayout() # 重新启用排序功能（但不会自动排序已填充的数据） self.config_table.setSortingEnabled(True) # 固定列宽（不随内容自适应） self._apply_table_column_widths() # 更新状态卡片统计（只统计真实数据） self._update_status_statistics() if getattr(self, "table_empty_label", None) is not None: self.table_empty_label.setVisible(False) if getattr(self, "page_info_label", None) is not None: self.page_info_label.setText(f"第 {self.current_page}/{total_pages} 页") self.is_updating_table = False self._update_checked_count() def _setup_model_view(self): """切换到大数据量 Model/View 模式""" headers = MODEL_VIEW_HEADERS if self.table_model is None: self.table_model = ConfigTableModel(self.configs, headers, self) self.table_proxy = QSortFilterProxyModel(self) self.table_proxy.setSourceModel(self.table_model) self.table_proxy.setFilterKeyColumn(-1) self.table_view.setModel(self.table_proxy) self.table_delegate = TableActionDelegate(self.table_view, self._edit_row_from_view, self._delete_row_from_view) self.table_view.setItemDelegate(self.table_delegate) header = self.table_view.horizontalHeader() header.setStretchLastSection(True) header.setSectionResizeMode(QHeaderView.Interactive) # 连接列宽调整信号，用于跟踪手动调整和自动调整 header.sectionResized.connect(self.on_table_view_column_resized) header.geometriesChanged.connect(self.on_table_view_geometry_changed) self._apply_table_view_column_widths() else: self.table_model.update_data(self.configs) self.use_model_view = True self.table_view.setVisible(True) self.config_table.setVisible(False) if hasattr(self, "page_first_btn"): for btn in [self.page_first_btn, self.page_prev_btn, self.page_next_btn, self.page_last_btn, self.page_size_combo]: btn.setEnabled(False) if hasattr(self, "table_empty_label"): self.table_empty_label.setVisible(len(self.configs) == 0) if hasattr(self, "page_info_label"): total_rows = len(self.configs) self.page_info_label.setText(f"大数据模式：{total_rows} 行") self._update_checked_count() self._show_infobar("warning", "提示", "数据量较大，已切换到Model/View模式（部分功能受限）") def _edit_row_from_view(self, index): """Model/View 编辑行""" if not index.isValid(): return edit_index = index.sibling(index.row(), 0) self.table_view.setCurrentIndex(edit_index) self.table_view.edit(edit_index) def _delete_row_from_view(self, index): """Model/View 删除行""" if not index.isValid(): return src_index = self.table_proxy.mapToSource(index) if src_index.isValid(): self.table_model.removeRows(src_index.row(), 1) def get_config_from_table(self, row_index=0): """从表格中获取指定行的配置数据（使用表格中修改后的值）""" if row_index >= self.config_table.rowCount(): return None def get_cell_text(row, col): """安全获取单元格文本""" item = self.config_table.item(row, col) return item.text().strip() if item else '' def get_cell_int_or_empty(row, col): """安全获取单元格整数或空字符串""" item = self.config_table.item(row, col) if item and item.text().strip(): try: return int(item.text().strip()) except ValueError: return '' # 无效值返回空字符串 return '' # 空值返回空字符串 config = { '多多id': get_cell_text(row_index, 1), # 第1列 '序号': get_cell_text(row_index, 2), # 第2列 '话题': get_cell_text(row_index, 3), # 第3列 '定时发布': get_cell_text(row_index, 4), # 第4列 '间隔时间': get_cell_int_or_empty(row_index, 5), # 第5列，空值保持为空 '达人链接': get_cell_text(row_index, 6), # 第6列 '执行人': get_cell_text(row_index, 7), # 第7列 '情况': get_cell_text(row_index, 8) or '待执行', # 第8列 '文件路径': get_cell_text(row_index, 9) # 第9列是文件路径 } return config @staticmethod def get_config(): """获取当前配置数据（已废弃，配置从Excel导入）""" # 配置现在从Excel导入，此方法返回None表示需要先导入Excel return None def update_data(self): """更新数据：找出文件并保存到各行的文件路径列""" # 防止连续点击导致重入，避免勾选框错位 if getattr(self, '_update_data_running', False): return try: self._update_data_running = True if hasattr(self, 'update_data_btn'): self.update_data_btn.setEnabled(False) if not self.configs: self._show_infobar("warning", "提示", "请先导入Excel配置文件") return # 获取文件夹路径 folder_path = self.folder_path_input.text().strip() if not folder_path: folder_path = get_default_folder_path() if not os.path.exists(folder_path): self._show_infobar("warning", "警告", f"文件夹路径不存在: {folder_path}") return self.log_text.append("=" * 50) self.log_text.append("开始批量更新文件路径...") self.log_text.append(f"共有 {len(self.configs)} 行配置需要处理") self.log_text.append(f"搜索根目录: {folder_path} （结构: 根目录/多多ID/序号(-xxx).mp4 或 序号(-xxx)/）") total_found_files = 0 rows_with_files = 0 skip_no_id = 0 no_match_log = [] # 标记正在更新，防止触发信号 self.is_updating_table = True # 遍历所有配置项进行更新 for config_idx, config in enumerate(self.configs): user_id = str(config.get('多多id', '')).strip() index = str(config.get('序号', '')).strip() if not user_id or not index: skip_no_id += 1 continue found_files = self._find_files_for_config(config, folder_path) if found_files: file_paths_str = "; ".join([str(f['path']) for f in found_files]) config['文件路径'] = file_paths_str rows_with_files += 1 total_found_files += len(found_files) else: config['文件路径'] = "" no_match_log.append(f"多多ID={user_id} 序号={index}") # 更新 UI 表格显示（跳过 sync：configs 已由更新数据写入，勿用表格回写覆盖） if self.use_model_view: if self.table_model: self.table_model.layoutChanged.emit() else: self.update_table(skip_sync=True) # 结束更新 self.is_updating_table = False if skip_no_id: self.log_text.append(f"跳过 {skip_no_id} 行（多多ID或序号为空）") if no_match_log: self.log_text.append(f"未匹配到文件 {len(no_match_log)} 行:") for s in no_match_log[:20]: self.log_text.append(f" · {s}") if len(no_match_log) > 20: self.log_text.append(f" ... 还有 {len(no_match_log) - 20} 行") total_rows = len(self.configs) self.log_text.append("=" * 50) self.log_text.append(f"更新完成！数据 {total_rows} 条，文件 {total_found_files} 个，匹配 {rows_with_files} 条") status_msg = f"数据 {total_rows} 条，文件 {total_found_files} 个，匹配 {rows_with_files} 条" self.update_status_label.setText(status_msg) self.update_status_label.setStyleSheet("color: #4CAF50; font-size: 10px;") self.set_status_cards(update_text=status_msg) self._update_status_statistics() # 更新映射 self._rebuild_row_map() # 计算并应用间隔时间规则 self.log_text.append("=" * 50) self.log_text.append("开始计算间隔时间并更新定时发布时间...") configs_with_rows = [] for i, cfg in enumerate(self.configs): configs_with_rows.append({"config_index": i, "config": cfg}) updated_count = self._apply_schedule_intervals(configs_with_rows) if updated_count > 0: self.log_text.append(f"✓ 已自动计算并更新 {updated_count} 行的定时发布时间") if not self.use_model_view: self.update_table(skip_sync=True) elif self.table_model: self.table_model.layoutChanged.emit() self.log_text.append("=" * 50) self._show_infobar("success", "成功", f"数据 {total_rows} 条，文件 {total_found_files} 个，匹配 {rows_with_files} 条") return except Exception as e: error_msg = f"更新数据失败: {str(e)}" self.log_text.append(error_msg) self._show_infobar("error", "错误", error_msg) logger.error(f"更新数据失败: {e}") import traceback traceback.print_exc() finally: self._update_data_running = False if hasattr(self, 'update_data_btn'): self.update_data_btn.setEnabled(True) @staticmethod def _index_matches_name(index, name_or_stem): """序号与文件名/文件夹名是否匹配。支持：序号、序号.mp4、序号-xxx、01 与 1 数字等价。""" if not name_or_stem or not index: return False s = str(name_or_stem).strip() if s == index: return True if s.startswith(index + "-"): return True parts = s.split("-") part0 = parts[0].strip() if parts else "" if part0 == index: return True try: if int(s) == int(index): return True if part0 and int(part0) == int(index): return True except (ValueError, TypeError): pass return False def _find_files_for_config(self, config, folder_path): """根据配置查找文件（辅助方法）。目录结构：文件夹路径/多多ID/[(子目录)/] 序号(-xxx).mp4 或 序号(-xxx)/""" found_files = [] if not config: logger.warning("配置为空，无法查找文件") return found_files if not folder_path or not os.path.exists(folder_path): logger.warning(f"文件夹路径无效或不存在: {folder_path}") return found_files index = str(config.get('序号', '')).strip() if not index: logger.warning("序号为空，无法查找文件") return found_files user_id = str(config.get('多多id', '')).strip() if not user_id: logger.warning("多多ID为空，无法查找文件") return found_files video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv', '.webm'] try: if not os.access(folder_path, os.R_OK): logger.error(f"没有权限读取文件夹: {folder_path}") return found_files try: sub_dirs = [entry for entry in os.listdir(folder_path) if os.path.isdir(os.path.join(folder_path, entry))] except (PermissionError, OSError) as e: logger.error(f"读取文件夹失败: {e}") return found_files target_subdir = None for subdir_name in sub_dirs: if subdir_name == user_id: target_subdir = os.path.join(folder_path, subdir_name) break if not target_subdir or not os.path.exists(target_subdir): return found_files def append_file(fpath): fpath_obj = Path(fpath) if not fpath_obj.exists(): return if fpath_obj.is_file(): if any(fpath_obj.suffix.lower() == ext for ext in video_extensions): found_files.append({ "url": config.get('达人链接', ''), "user_id": user_id, "time_start": config.get('定时发布', '') if config.get('定时发布') else None, "ht": config.get('话题', ''), "index": index, "path": fpath_obj }) elif fpath_obj.is_dir(): found_files.append({ "url": config.get('达人链接', ''), "user_id": user_id, "time_start": config.get('定时发布', '') if config.get('定时发布') else None, "ht": config.get('话题', ''), "index": index, "path": fpath_obj }) search_dirs = [target_subdir] try: for sub in os.listdir(target_subdir): p = os.path.join(target_subdir, sub) if os.path.isdir(p): search_dirs.append(p) except (PermissionError, OSError): pass for search_dir in search_dirs: try: dir_items = os.listdir(search_dir) except (PermissionError, OSError): continue for item_name in dir_items: if item_name.startswith('.'): continue item_path = os.path.join(search_dir, item_name) try: path_obj = Path(item_path) if path_obj.is_file(): base = path_obj.stem else: base = item_name if not self._index_matches_name(index, base): continue append_file(item_path) except (OSError, ValueError) as e: logger.warning(f"处理 {item_name} 时出错: {e}") continue except (OSError, ValueError) as e: logger.error(f"查找文件失败: {e}", exc_info=True) return found_files def execute_task(self): """执行任务""" try: # 检查是否有Excel导入的配置 if self.configs: # 检查用户是否已经勾选了任何项 has_user_selection = any(cfg.get('勾选', False) for cfg in self.configs) # 只有当用户没有勾选任何项时，才自动勾选失败项 if not has_user_selection: failed_indices = [] for idx, cfg in enumerate(self.configs): status = cfg.get('情况', '') if "失败" in status or "错误" in status or "过期" in status or "跳过" in status: failed_indices.append(idx) if failed_indices: for idx, cfg in enumerate(self.configs): cfg['勾选'] = idx in failed_indices self.update_table() self._show_infobar("info", "提示", f"检测到 {len(failed_indices)} 条失败记录，已自动仅选择失败项") # 如果有Excel配置，批量处理 self.execute_batch_from_excel() return # 批量处理完成后直接返回 # 没有Excel导入的配置，提示用户先导入 self._show_infobar("warning", "提示", "请先导入Excel配置文件") return except Exception as e: import traceback error_detail = traceback.format_exc() logger.error(f"执行任务失败: {e}\n{error_detail}") try: self._show_infobar("error", "错误", f"执行任务失败: {str(e)}") self.log_text.append(f"执行任务失败: {str(e)}") self.log_text.append(f"错误详情: {error_detail}") except: pass self._set_task_buttons_state('idle') self.progress_bar.setVisible(False) def execute_batch_from_excel(self): """从 Excel配置批量执行（自动判断相同多多ID的mp4文件，批量上传）""" # 执行前强制同步当前页数据，确保手动修改的内容被包含 if not self.use_model_view: self._sync_configs_from_table() # 从表格当前页勾选框同步勾选状态到 configs，确保执行的是用户当前勾选的行 self._sync_checked_from_table() # 开始新任务时，从当前数据中统计已有的成功/失败/待执行数量（累计历史数据） existing_success = 0 existing_failed = 0 existing_pending = 0 for config in self.configs: status = config.get('情况', '待执行') if "完成" in status or "成功" in status: existing_success += 1 elif "失败" in status or "错误" in status or "过期" in status or "跳过" in status: existing_failed += 1 existing_pending += 1 # 失败的也算待执行 elif "待" in status or not status: existing_pending += 1 self.batch_success_count = existing_success self.batch_failed_count = existing_failed self.set_status_cards(pending=existing_pending, running=0, success=existing_success, failed=existing_failed) # 获取文件夹路径 folder_path = self.folder_path_input.text().strip() if not folder_path: folder_path = get_default_folder_path() if not os.path.exists(folder_path): self._show_infobar("warning", "警告", f"文件夹路径不存在: {folder_path}") return # 筛选勾选的待处理配置（直接从 self.configs 获取最新数据） checked_indices = [i for i, cfg in enumerate(self.configs) if cfg.get('勾选', False)] if not checked_indices: self._show_infobar("warning", "提示", "请先勾选需要上传的数据行") return # 分析勾选项 all_configs_with_files = [] configs_to_process = [] # 用于计算间隔时间 for idx in checked_indices: config = self.configs[idx] # 跳过状态为「已完成」的任务（仅上传勾选且未完成的项） status = (config.get('情况') or '').strip() if '已完成' in status: continue # 验证必填 if not config.get('多多id') or not config.get('序号'): continue configs_to_process.append({"config_index": idx, "config": config}) if not configs_to_process: self._show_infobar("warning", "提示", "所选项已完成或数据不完整") return # 重置所有要处理的配置状态为"待执行"（确保第二次运行时清除旧状态） for item in configs_to_process: idx = item["config_index"] self.configs[idx]['情况'] = '待执行' self._update_table_status(idx, "待执行", is_config_index=True) # 重置任务状态后，重新统计成功/失败/待执行数量以保持一致性 existing_success = 0 existing_failed = 0 existing_pending = 0 for config in self.configs: status = config.get('情况', '待执行') if "完成" in status or "成功" in status: existing_success += 1 elif "失败" in status or "错误" in status or "过期" in status or "跳过" in status: existing_failed += 1 existing_pending += 1 # 失败的也算待执行 elif "待" in status or not status: existing_pending += 1 self.batch_success_count = existing_success self.batch_failed_count = existing_failed self.set_status_cards(pending=existing_pending, success=existing_success, failed=existing_failed) # 注意：不再在此处调用 _apply_schedule_intervals # 间隔时间计算已在"更新数据"按钮中完成，用户可能在之后手动修改了时间，应保留用户修改 self.log_text.append("=" * 50) self.log_text.append(f"开始分析配置，准备批量上传...") for item in configs_to_process: idx = item["config_index"] config = item["config"] # 从已保存的文件路径中获取文件（由"更新数据"按钮写入） file_path_str = config.get('文件路径', '').strip() found_files = [] if file_path_str: file_paths = [p.strip() for p in file_path_str.split(';') if p.strip()] for fp in file_paths: if os.path.exists(fp): found_files.append({ "url": config.get('达人链接', ''), "user_id": config.get('多多id', ''), "time_start": config.get('定时发布', '') if config.get('定时发布') else None, "ht": config.get('话题', ''), "index": config.get('序号', ''), "path": Path(fp) }) else: self.log_text.append(f" ⚠ 文件路径不存在，已跳过: {fp}") if not found_files and not file_path_str: self.log_text.append(f" 索引 {idx+1} ({config.get('多多id')}): 未找到文件路径，请先点击'更新数据'按钮") if found_files: all_configs_with_files.append({ 'config': config, 'files': found_files, 'config_index': idx }) self.log_text.append(f"索引 {idx+1} ({config.get('多多id')}): 准备上传 {len(found_files)} 个项目") if not all_configs_with_files: self._show_infobar("warning", "警告", "未找到任何匹配文件，请先点击‘更新数据’按钮") return total_tasks = sum(len(item['files']) for item in all_configs_with_files) self.set_status_cards(pending=total_tasks) self.set_running_progress(0, total_tasks) # 按多多ID分组任务 from collections import defaultdict grouped_by_user_id = defaultdict(list) for item in all_configs_with_files: user_id = item['config'].get('多多id', '') grouped_by_user_id[user_id].append(item) # 检查线程 if self.worker_thread and self.worker_thread.isRunning(): self._show_infobar("warning", "警告", "已有任务正在执行，请等待完成") return # 重置暂停/终止状态 self._is_paused = False self._is_terminated = False self._set_task_buttons_state('running') self.progress_bar.setVisible(True) self.progress_bar.setValue(0) # 构建任务队列 self.batch_task_queue = [] self.current_batch_task_index = 0 self.batch_total_tasks = total_tasks self.batch_processed = 0 self.batch_pending_tasks = total_tasks video_extensions = ['.mp4', '.avi', '.mov', '.mkv', '.flv', '.wmv', '.webm'] # 获取用户是否勾选了"批量上传"复选框 use_batch_upload = self.batch_upload_checkbox.isChecked() self.log_text.append(f"批量上传模式: {'已勾选' if use_batch_upload else '未勾选'}") # 获取最大批量数（单次上限数） batch_limit = 5 # 默认值 try: batch_limit_text = self.batch_limit_input.text().strip() if batch_limit_text: batch_limit = int(batch_limit_text) if batch_limit < 1: batch_limit = 1 except (ValueError, AttributeError): batch_limit = 5 self.log_text.append(f"单次上限数: {batch_limit}") def _skip_expired_and_append(file_info, file_index, group_items, _cfg_indices, into_videos, into_non_videos, file_is_video): """若定时过期则更新状态并返回 True（失败(定时过期)），否则加入列表并返回 False""" f_time_start = file_info.get('time_start', '') if self._is_schedule_time_expired(f_time_start): self.log_text.append(f" 跳过序号 {file_index}：定时发布时间已过期 ({f_time_start})") expire_idx = next((it['config_index'] for it in group_items if it['config'].get('序号') == file_index), None) if expire_idx is not None: self._update_table_status(expire_idx, "失败(定时过期)", is_config_index=True) self.configs[expire_idx]['情况'] = '失败(定时过期)' self.batch_failed_count = getattr(self, "batch_failed_count", 0) + 1 self.set_status_cards(failed=self.batch_failed_count) return True if file_is_video: into_videos.append(file_info) else: into_non_videos.append(file_info) return False # 按 config 顺序确定多多ID 的迭代顺序（先出现的多多ID 先处理） def _first_config_index(pair): return min(it['config_index'] for it in pair[1]) sorted_groups = sorted(grouped_by_user_id.items(), key=_first_config_index) for user_id, items in sorted_groups: all_files = [] related_config_indices = [] for item in items: all_files.extend(item['files']) if item['config_index'] not in related_config_indices: related_config_indices.append(item['config_index']) def get_sort_key(file_entry): try: return int(file_entry.get('index', '0')) except (ValueError, TypeError): return 0 all_files_sorted = sorted(all_files, key=get_sort_key) first_config = items[0].get('config', {}) if not use_batch_upload: # 未勾选批量上传：按序号一条一条上传，先完成当前多多ID的 1,2,3,4 再处理下一个多多ID i = 0 while i < len(all_files_sorted): current_file = all_files_sorted[i] is_video = current_file['path'].is_file() and any( current_file['path'].suffix.lower() == ext for ext in video_extensions) f_index = current_file.get('index', '') if _skip_expired_and_append(current_file, f_index, items, related_config_indices, [], [], is_video): i += 1 continue matching_idx = next( (it['config_index'] for it in items if it['config'].get('序号') == f_index), related_config_indices[0] if related_config_indices else 0) matching_config = next( (it['config'] for it in items if it['config'].get('序号') == f_index), first_config) if is_video: self.batch_task_queue.append({ 'type': 'single_video', 'config': matching_config, 'files': [current_file], 'user_id': user_id, 'count': 1, 'config_indices': [matching_idx] }) else: self.batch_task_queue.append({ 'type': 'image_folder', 'config': matching_config, 'files': [current_file], 'user_id': user_id, 'count': 1, 'config_indices': [matching_idx] }) i += 1 else: # 勾选批量上传：严格按序号顺序处理。遇到图文立即上传；第一次遇到视频时，收集该多多ID下全部视频按上限分批上传，再继续后续序号（图文照常上传） ordered_list = [] # (f, is_video) 按序号顺序，已排除定时过期 for f in all_files_sorted: is_video = f['path'].is_file() and any( f['path'].suffix.lower() == ext for ext in video_extensions) f_index = f.get('index', '') if _skip_expired_and_append(f, f_index, items, related_config_indices, [], [], is_video): continue ordered_list.append((f, is_video)) videos_in_order = [entry for (entry, iv) in ordered_list if iv] videos_emitted = False for (f, is_video) in ordered_list: f_index = f.get('index', '') if not is_video: matching_idx = next( (it['config_index'] for it in items if it['config'].get('序号') == f_index), related_config_indices[0]) matching_config = next( (it['config'] for it in items if it['config'].get('序号') == f_index), first_config) self.batch_task_queue.append({ 'type': 'image_folder', 'config': matching_config, 'files': [f], 'user_id': user_id, 'count': 1, 'config_indices': [matching_idx] }) else: if not videos_emitted: for start in range(0, len(videos_in_order), batch_limit): chunk = videos_in_order[start:start + batch_limit] batch_config_indices = [] for fc in chunk: fi = fc.get('index', '') match_idx = next((it['config_index'] for it in items if it['config'].get('序号') == fi), None) if match_idx is not None and match_idx not in batch_config_indices: batch_config_indices.append(match_idx) if len(chunk) > 1: self.batch_task_queue.append({ 'type': 'batch_video', 'config': first_config, 'files': chunk, 'user_id': user_id, 'count': len(chunk), 'config_indices': batch_config_indices }) else: vid_index = chunk[0].get('index', '') matching_config = next( (it['config'] for it in items if it['config'].get('序号') == vid_index), first_config) self.batch_task_queue.append({ 'type': 'single_video', 'config': matching_config, 'files': chunk, 'user_id': user_id, 'count': 1, 'config_indices': batch_config_indices }) videos_emitted = True # 已在该序号前统一发过视频批次，此处跳过 if self.batch_task_queue: self._process_next_batch_task() else: self._show_infobar("warning", "警告", "任务分析失败，未构建有效队列") self._set_task_buttons_state('idle') self.progress_bar.setVisible(False) def _cleanup_worker_thread(self): """安全清理工作线程""" if not self.worker_thread: return try: # 如果线程正在运行，请求停止 if self.worker_thread.isRunning(): # 请求停止（优雅方式） self.worker_thread.stop() self.worker_thread.requestInterruption() # 等待线程结束，设置合理超时 if not self.worker_thread.wait(2000): logger.warning("工作线程未能在2秒内停止") # 不使用 terminate()，继续处理 # 安全断开所有信号连接 try: self.worker_thread.finished.disconnect() except (TypeError, RuntimeError): pass # 信号未连接或已断开 try: self.worker_thread.log_message.disconnect() except (TypeError, RuntimeError): pass try: self.worker_thread.progress.disconnect() except (TypeError, RuntimeError): pass try: self.worker_thread.item_result.disconnect() except (TypeError, RuntimeError): pass except Exception as e: logger.warning(f"清理工作线程时出错: {e}") finally: self.worker_thread = None def _set_task_buttons_state(self, state): """设置任务控制按钮的显示状态 state: 'idle' | 'running' | 'paused' """ if state == 'idle': self.execute_btn.setEnabled(True) self.pause_btn.setVisible(False) self.resume_btn.setVisible(False) self.terminate_btn.setVisible(False) elif state == 'running': self.execute_btn.setEnabled(False) self.pause_btn.setVisible(True) self.resume_btn.setVisible(False) self.terminate_btn.setVisible(True) elif state == 'paused': self.execute_btn.setEnabled(False) self.pause_btn.setVisible(False) self.resume_btn.setVisible(True) self.terminate_btn.setVisible(True) def pause_task(self): """暂停任务：当前正在执行的任务会完成，但不再启动下一个""" self._is_paused = True self._set_task_buttons_state('paused') self.log_text.append("=" * 50) self.log_text.append("⏸ 任务已暂停，当前正在执行的任务完成后将停止。点击「继续」恢复执行。") self._show_infobar("warning", "已暂停", "当前任务完成后将暂停，点击「继续」恢复") def resume_task(self): """继续执行暂停的任务""" self._is_paused = False self._set_task_buttons_state('running') self.log_text.append("=" * 50) self.log_text.append("▶ 任务已恢复，继续执行剩余任务...") self._show_infobar("success", "已恢复", "继续执行剩余任务") # 继续处理下一个任务 self._process_next_batch_task() def terminate_task(self): """终止所有任务""" reply = QMessageBox.question( self, "确认终止", "确定要终止所有任务吗？当前正在执行的任务将被中断。", QMessageBox.Yes | QMessageBox.No ) if reply != QMessageBox.Yes: return self._is_terminated = True self._is_paused = False self.log_text.append("=" * 50) self.log_text.append("⏹ 正在终止任务...") # 停止当前工作线程 self._cleanup_worker_thread() # 将队列中所有未执行的任务标记为"已终止" remaining = 0 for i in range(self.current_batch_task_index, len(self.batch_task_queue)): task = self.batch_task_queue[i] config_indices = task.get('config_indices', []) for cfg_idx in config_indices: try: if self.configs[cfg_idx].get('情况', '') in ('待执行', '执行中'): self.configs[cfg_idx]['情况'] = '已终止' self._update_table_status(cfg_idx, "已终止", is_config_index=True) remaining += 1 except (IndexError, KeyError): pass # 清空任务队列 self.batch_task_queue = [] self.current_batch_task_index = 0 # 重置 UI 状态 self._set_task_buttons_state('idle') self.progress_bar.setVisible(False) self._is_terminated = False self.log_text.append(f"⏹ 任务已终止。{remaining} 个待执行任务被取消。") self.log_text.append(f" 已完成: {self.batch_success_count} 成功, {self.batch_failed_count} 失败") self._update_status_statistics() self._show_infobar("warning", "已终止", f"任务已终止，{remaining} 个任务被取消") def _process_next_batch_task(self): """处理任务队列中的下一个任务（异步，不阻塞GUI）""" # 检查是否还有任务 if self.current_batch_task_index >= len(self.batch_task_queue): # 所有任务完成 self.progress_bar.setValue(100) self.log_text.append("=" * 50) self.log_text.append(f"所有任务执行完成！共处理 {self.batch_processed} 个文件/文件夹") self._set_task_buttons_state('idle') self.progress_bar.setVisible(False) self.set_running_progress(0, 0) # 更新状态统计（成功/失败/待执行数量） self._update_status_statistics() self._show_infobar("success", "任务完成", f"共处理 {self.batch_processed} 个文件/文件夹") # 重置任务队列 self.batch_task_queue = [] self.current_batch_task_index = 0 return # 获取当前任务 task = self.batch_task_queue[self.current_batch_task_index] task_type = task['type'] config = task['config'] files = task['files'] _ = task['user_id'] # 仅提取以验证存在性 # 根据任务类型处理 try: # 清理旧线程（如果存在） self._cleanup_worker_thread() # 验证 files 参数 if not files or not isinstance(files, list): raise ValueError(f"无效的 files 参数: {files}") # 确定是否为批量模式 is_batch = (task_type == 'batch_video' and len(files) > 1) # 创建并启动工作线程 self.worker_thread = WorkerThread(config, is_batch, files, self) # 连接信号 self.worker_thread.finished.connect(self._on_batch_task_finished) self.worker_thread.log_message.connect(self.log_text.append) self.worker_thread.progress.connect(self.progress_bar.setValue) self.worker_thread.item_result.connect(self._on_worker_item_result) # 记录任务信息 if task_type == 'batch_video': self.log_text.append(f"\n开始批量上传 {len(files)} 个视频文件...") elif task_type == 'single_video': self.log_text.append(f"\n开始上传单个视频文件...") elif task_type == 'image_folder': idx = task.get('index', 0) total = task.get('total', 0) folder_index = task.get('folder_index', '') self.log_text.append(f"\n开始上传第 {idx}/{total} 个图片文件夹（序号: {folder_index}）...") # 更新表格状态为"执行中" try: config_indices = task.get('config_indices', []) if config_indices: for cfg_idx in config_indices: try: self._update_table_status(cfg_idx, "执行中", is_config_index=True) except Exception as e: logger.warning(f"更新状态失败（索引{cfg_idx}）: {e}") except Exception as e: logger.warning(f"更新执行中状态失败: {e}") # 启动线程（不阻塞） try: self.worker_thread.start() except Exception as e: error_msg = f"启动线程失败: {str(e)}" logger.error(error_msg) self.log_text.append(f" ✗ {error_msg}") raise except Exception as e: error_msg = f"启动任务失败: {str(e)}" self.log_text.append(f" ✗ {error_msg}") logger.error(error_msg, exc_info=True) # 即使失败也继续下一个任务，立即更新表格为失败并增加失败条数 count = task.get('count', 1) config_indices = task.get('config_indices', []) for cfg_idx in config_indices: try: self._update_table_status(cfg_idx, "失败", is_config_index=True) except Exception: pass self.batch_failed_count += len(config_indices) if config_indices else 1 self.batch_processed += count self.batch_pending_tasks = max(self.batch_pending_tasks - count, 0) self.set_status_cards( pending=self.batch_pending_tasks, success=getattr(self, 'batch_success_count', 0), failed=getattr(self, 'batch_failed_count', 0) ) self.set_running_progress(self.batch_processed, self.batch_total_tasks) self.current_batch_task_index += 1 if not self._is_terminated and not self._is_paused: QApplication.processEvents() self._process_next_batch_task() def _on_batch_task_finished(self, success, message): """批量任务完成回调（不阻塞GUI）""" try: # 获取当前任务（注意：此时任务已完成，但索引还未更新） if self.current_batch_task_index < len(self.batch_task_queue): task = self.batch_task_queue[self.current_batch_task_index] task_type = task['type'] count = task.get('count', 1) config_indices = task.get('config_indices', []) # 更新进度日志 if success: if task_type == 'batch_video': self.log_text.append(f" ✓ 批量上传 {count} 个视频完成") elif task_type == 'single_video': self.log_text.append(f" ✓ 单个视频上传完成") elif task_type == 'image_folder': self.log_text.append(f" ✓ 图片文件夹上传完成") else: reason_text = f"失败原因: {message}" if message else "失败原因: 未知" self.log_text.append(f" ✗ 任务失败: {reason_text}") # 对于 batch_video 类型，状态和计数已经在 _on_worker_item_result 中实时更新了 # 所以这里不再重复更新，只需要处理 single_video 和 image_folder 类型 if task_type != 'batch_video': if success: # 更新表格为"已完成"，并增加成功条数 for cfg_idx in config_indices: self._update_table_status(cfg_idx, "已完成", is_config_index=True) self.batch_success_count += len(config_indices) else: # 更新表格为"失败"，并增加失败条数 for cfg_idx in config_indices: self._update_table_status(cfg_idx, "失败", is_config_index=True) self.batch_failed_count += len(config_indices) # 更新统计（single_video 和 image_folder 需要在这里更新） self.batch_processed += count self.batch_pending_tasks = max(self.batch_pending_tasks - count, 0) self.set_status_cards( pending=self.batch_pending_tasks, success=self.batch_success_count, failed=self.batch_failed_count ) self.set_running_progress(self.batch_processed, self.batch_total_tasks) # 移动到下一个任务 self.current_batch_task_index += 1 # 获取发布间隔时间（毫秒） interval_ms = self._get_publish_interval_ms() if interval_ms > 0 and self.current_batch_task_index < len(self.batch_task_queue): self.log_text.append(f" 等待 {interval_ms // 1000} 秒后执行下一个任务...") # 检查是否被终止 if self._is_terminated: return # 检查是否被暂停 if self._is_paused: self.log_text.append("⏸ 当前任务已完成，等待用户点击「继续」...") self._set_task_buttons_state('paused') return # 处理下一个任务（使用QTimer延迟，包含发布间隔时间） delay_ms = max(100, interval_ms) # 至少100ms确保GUI更新 QTimer.singleShot(delay_ms, self._process_next_batch_task) except Exception as e: logger.error(f"批量任务完成回调失败: {e}") import traceback traceback.print_exc() # 即使出错也继续处理下一个任务（除非已暂停或终止） if not self._is_terminated and not self._is_paused and self.current_batch_task_index < len(self.batch_task_queue): self.current_batch_task_index += 1 QTimer.singleShot(100, self._process_next_batch_task) def _get_publish_interval_ms(self): """获取发布间隔时间（毫秒）""" try: if not hasattr(self, 'publish_interval_input'): return 0 value_str = self.publish_interval_input.text().strip().lower() if not value_str or value_str == '0': return 0 # 解析时间格式：数字(秒)、30s(秒)、2m(分钟) if value_str.endswith('m') or value_str.endswith('分钟'): # 分钟 num_str = value_str.replace('m', '').replace('分钟', '').strip() return int(float(num_str) * 60 * 1000) elif value_str.endswith('s') or value_str.endswith('秒'): # 秒 num_str = value_str.replace('s', '').replace('秒', '').strip() return int(float(num_str) * 1000) else: # 默认为秒 return int(float(value_str) * 1000) except (ValueError, TypeError): return 0 def _rebuild_row_map(self): """重建 多多ID+序号 -> 表格行号 映射（仅针对当前页可见行）""" m = {} try: if not hasattr(self, "config_table") or self.use_model_view: self._row_map_by_user_index = {} return for r in range(self.config_table.rowCount()): # 多多ID在第1列，序号在第2列（第0列是勾选框） user_id = self.get_cell_text(r, 1) idx = self.get_cell_text(r, 2) if user_id and idx: m[(user_id, idx)] = r except Exception: pass self._row_map_by_user_index = m def _on_worker_item_result(self, payload): """接收自动化侧逐条结果 - 仅用于 batch_video 类型任务的实时状态更新""" try: if not isinstance(payload, dict): return user_id = str(payload.get("user_id", "")).strip() idx = str(payload.get("index", "")).strip() ok = bool(payload.get("ok")) reason = str(payload.get("reason", "")).strip() name = str(payload.get("name", "")).strip() if not user_id: return # 检查当前任务类型，只有 batch_video 类型才在这里更新计数 # single_video 和 image_folder 类型在 _on_batch_task_finished 中更新 is_batch_video_task = False if hasattr(self, 'current_batch_task_index') and self.current_batch_task_index < len(self.batch_task_queue): current_task = self.batch_task_queue[self.current_batch_task_index] is_batch_video_task = current_task.get('type') == 'batch_video' # 全局搜索匹配的多多ID和序号 found_config_idx = -1 updated_count = 0 # 记录更新了多少条配置 if idx: # 如果有序号，优先通过多多ID和序号匹配 for i, cfg in enumerate(self.configs): if str(cfg.get("多多id")) == user_id and str(cfg.get("序号")) == idx: found_config_idx = i break # 如果通过序号没找到，尝试通过多多ID匹配 if found_config_idx == -1: # 查找所有匹配多多ID的配置 matching_indices = [] for i, cfg in enumerate(self.configs): if str(cfg.get("多多id")) == user_id: matching_indices.append(i) # 如果只找到一个匹配的配置，直接使用它 if len(matching_indices) == 1: found_config_idx = matching_indices[0] # 如果有多个匹配的配置，且是批量视频任务，更新相关配置的状态 elif len(matching_indices) > 1 and is_batch_video_task: current_task = self.batch_task_queue[self.current_batch_task_index] task_config_indices = current_task.get('config_indices', []) # 只更新当前任务相关的配置状态 for cfg_idx in task_config_indices: if cfg_idx in matching_indices: self._update_table_status(cfg_idx, "已完成" if ok else "失败", is_config_index=True) updated_count += 1 found_config_idx = -2 # 标记为已处理（多个配置） if found_config_idx >= 0: # 单个配置匹配成功，更新表格状态 self._update_table_status(found_config_idx, "已完成" if ok else "失败", is_config_index=True) updated_count = 1 label = name if name else payload.get("path", "") or "" reason_text = f"失败原因: {reason}" if (not ok and reason) else reason self.log_text.append(f"[结果] {user_id}-{idx}: {'✓' if ok else '✗'} {label} {reason_text}") elif found_config_idx == -2: # 多个配置已处理，只记录日志 label = name if name else payload.get("path", "") or "" reason_text = f"失败原因: {reason}" if (not ok and reason) else reason self.log_text.append(f"[结果] {user_id}-{idx}: {'✓' if ok else '✗'} {label} {reason_text}") else: reason_text = f"失败原因: {reason}" if (not ok and reason) else reason self.log_text.append(f"[结果] {user_id}-{idx}: ok={ok} {reason_text} (未在列表中找到匹配项)") # 只有 batch_video 类型任务才在这里更新计数（实时反馈） # single_video 和 image_folder 在 _on_batch_task_finished 中更新，避免重复计数 if is_batch_video_task and updated_count > 0: if ok: self.batch_success_count += updated_count else: self.batch_failed_count += updated_count # 更新待处理数量 self.batch_pending_tasks = max(self.batch_pending_tasks - updated_count, 0) # 立即刷新状态卡片显示 self.set_status_cards( pending=self.batch_pending_tasks, success=self.batch_success_count, failed=self.batch_failed_count ) # 更新进度 self.batch_processed += updated_count self.set_running_progress(self.batch_processed, self.batch_total_tasks) except Exception as e: logger.warning(f"处理单条结果失败: {e}") @staticmethod def count_videos_in_folder(folder_path, index): """统计文件夹中匹配序号的视频文件数量（与main.py逻辑一致）""" count = 0 try: # 遍历最外层文件夹下的所有子文件夹（与main.py逻辑一致） for file in os.listdir(folder_path): # 获取文件夹下所有的文件夹 file_path = os.path.join(folder_path, file) # 拼接文件夹 # 检查是否为目录，跳过文件（如.lnk快捷方式） if not os.path.isdir(file_path): continue files = os.listdir(file_path) # 获取用户id下的文件 for file_name in files: # 检查是否是视频文件（.mp4） if ".mp4" in file_name: # 用"-"分割文件名，检查第一部分是否等于序号 # 文件名格式：4-茶叶蛋大冒险-.mp4 -> ['4', '茶叶蛋大冒险', '', 'mp4'] file_names = file_name.split("-") if len(file_names) > 0 and file_names[0] == str(index): path = Path(os.path.join(file_path, file_name)) # 判断是否为文件 if path.is_file(): count += 1 else: # 如果是文件夹，统计其中的文件 for sub_file in os.listdir(path): sub_path = Path(os.path.join(path, sub_file)) if sub_path.is_file(): count += 1 except (OSError, PermissionError) as e: logger.error(f"统计视频文件失败: {e}") return count def on_task_finished(self, success, message): """任务完成回调（单个任务）""" self.progress_bar.setValue(100) self.set_running_progress(0, 0) if success: self._show_infobar("success", "成功", message) # 更新表格状态为"已完成" # 查找对应的行（通过配置信息） self._update_single_task_status(success) else: self._show_infobar("error", "失败", message) # 更新表格状态为"失败" self._update_single_task_status(success) # 更新状态统计（成功/失败/待执行数量） self._update_status_statistics() # 恢复按钮 self._set_task_buttons_state('idle') self.log_text.append(f"任务完成: {message}") self.log_text.append("=" * 50) def _update_single_task_status_start(self, config): """更新单个任务的状态为"执行中"（根据配置查找对应的表格行）""" try: # 检查是否有表格 if not hasattr(self, 'config_table') or self.config_table.rowCount() == 0: return user_id = config.get('多多id', '') index = config.get('序号', '') if not user_id or not index: return # 在表格中查找匹配的行 for row_idx in range(self.config_table.rowCount()): try: row_user_id = self.get_cell_text(row_idx, 0) row_index = self.get_cell_text(row_idx, 1) if row_user_id == user_id and row_index == index: self._update_table_status(row_idx, "执行中") break except Exception as e: logger.warning(f"更新状态时出错（行{row_idx}）: {e}") continue except Exception as e: logger.error(f"更新任务状态失败: {e}") import traceback traceback.print_exc() def _update_single_task_status(self, success): """更新单个任务的状态（根据当前配置查找对应的表格行）""" try: # 检查是否有表格 if not hasattr(self, 'config_table') or self.config_table.rowCount() == 0: return # 获取当前配置（从worker_thread中获取） if not self.worker_thread: return config = self.worker_thread.config_data user_id = config.get('多多id', '') index = config.get('序号', '') if not user_id or not index: return # 在表格中查找匹配的行 for row_idx in range(self.config_table.rowCount()): try: row_user_id = self.get_cell_text(row_idx, 0) row_index = self.get_cell_text(row_idx, 1) if row_user_id == user_id and row_index == index: status = "已完成" if success else "失败" self._update_table_status(row_idx, status) break except Exception as e: logger.warning(f"更新状态时出错（行{row_idx}）: {e}") continue except Exception as e: logger.error(f"更新任务状态失败: {e}") import traceback traceback.print_exc() def get_cell_text(self, row, col): """获取表格单元格文本""" try: if not hasattr(self, 'config_table'): return "" if row < 0 or row >= self.config_table.rowCount(): return "" item = self.config_table.item(row, col) return item.text().strip() if item else "" except Exception as e: logger.warning(f"获取单元格文本失败（行{row}，列{col}）: {e}") return "" def closeEvent(self, event): """关闭事件""" if self._is_closing: event.accept() return if self.worker_thread and self.worker_thread.isRunning(): reply = QMessageBox.question( self, "确认", "任务正在执行中，确定要退出吗？", QMessageBox.Yes | QMessageBox.No ) if reply == QMessageBox.Yes: self._is_closing = True # 使用统一的线程清理方法 self._cleanup_worker_thread() event.accept() else: event.ignore() else: event.accept() def exception_handler(exc_type, exc_value, exc_traceback): """全局异常处理器""" if issubclass(exc_type, KeyboardInterrupt): sys.__excepthook__(exc_type, exc_value, exc_traceback) return # 防止递归：如果异常处理器本身出错，使用默认处理器 if exc_type is RecursionError: # 对于递归错误，直接打印到控制台，避免再次触发递归 print(f"递归错误: {exc_value}") print("这通常是由于无限递归调用导致的") return try: import traceback # 限制堆栈深度，避免递归错误 error_msg = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback, limit=50)) logger.critical(f"未捕获的异常:\n{error_msg}") # 尝试显示错误对话框 try: from PyQt5.QtWidgets import QMessageBox msg = QMessageBox() msg.setIcon(QMessageBox.Critical) msg.setWindowTitle("程序错误") msg.setText("程序发生未处理的错误") # 限制详细文本长度 detailed_text = error_msg[:2000] if len(error_msg) > 2000 else error_msg msg.setDetailedText(detailed_text) msg.exec_() except: # 如果无法显示对话框，至少打印到控制台 print(f"未捕获的异常:\n{error_msg[:1000]}") # 限制输出长度 except Exception: # 如果异常处理器本身出错，使用默认处理器 sys.__excepthook__(exc_type, exc_value, exc_traceback) def main(): # 设置全局异常处理器 sys.excepthook = exception_handler app = QApplication(sys.argv) # noinspection SpellCheckingInspection # 解决 macOS 上缺失 Segoe UI 字体导致的警告 if sys.platform == "darwin": font = QFont(".AppleSystemUIFont", 10) font.setFamilies([".AppleSystemUIFont", "PingFang SC", "Helvetica Neue", "Arial"]) app.setFont(font) setTheme(Theme.LIGHT) try: window = MainWindow() window.show() sys.exit(app.exec_()) except Exception as e: import traceback error_detail = traceback.format_exc() logger.critical(f"程序启动失败: {e}\n{error_detail}") print(f"程序启动失败: {e}\n{error_detail}") sys.exit(1) if __name__ == '__main__': main()