Merge branch 'master' of https://gitee.com/TeaCodeNice/crawler-plugin

app/amazon/approve - 副本.py

@@ -0,0 +1,999 @@
+import time
+import re
+import traceback
+from DrissionPage._pages.chromium_tab import ChromiumTab
+
+from config import runing_task, runing_shop
+from datetime import datetime
+from amazon.del_brand import AmamzonBase, kill_process
+
+# 导入 webview 用于前端通知
+try:
+    import webview
+except ImportError:
+    webview = None
+
+class AmzoneApprove(AmamzonBase):
+
+    def SwitchPage(self):
+        """
+        切换至 管理所有库存页面
+        1、等待 //navigation-favorites-bar[@class="hydrated"] 出现
+        """
+        navigation = self.tab.ele('xpath://navigation-favorites-bar[@class="hydrated"]')
+        navigation.wait.displayed(raise_err=False)
+        page_btn = navigation.sr('xpath://internal-fav-bar-links[@data-internal="navigation"]').sr(
+            'xpath://a[@data-page-id="ezdpc-gui-inventory-mons"]')
+        page_btn.wait.displayed(raise_err=False)
+        page_btn.click(timeout=5)
+
+        self.tab.wait.doc_loaded()
+        # 等待搜索框出现
+        search_region = self.tab.ele('xpath://div[@id="searchBoxContainer"]//kat-input-group')
+        search_region.wait.displayed(raise_err=False)
+
+
+    def search(self,filter_type="ApprovalRequired"):
+        sku_ls = []
+
+        load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]",timeout=5)
+        if len(load_ele) > 0:
+            load_ele[0].wait.deleted(timeout=3, raise_err=False)
+        time.sleep(0.5)
+
+        drop_down = self.tab.ele('xpath://div[contains(@class,"VolusListingStatusDropDown-module__verticalContainer")]//kat-dropdown')
+        drop_down.wait.displayed(raise_err=False)
+        drop_down.wait.enabled(raise_err=False)
+        time.sleep(0.6)
+        drop_down.click()
+        # //kat-option[@value="SearchSuppressed"]
+        xp = f'xpath://kat-option[@value="{filter_type}"]'
+        print(f"正在寻找筛选条件 {filter_type}，xpath: {xp}")
+        approval_required = self.tab.eles(xp,timeout=5)
+        if len(approval_required) == 0:
+            print(f"【没有需要{filter_type}选项】没有需要{filter_type}的商品了")
+            return sku_ls  # "没有需要审批的商品了"
+        else:
+            approval_required = approval_required[0]
+        approval_required.wait.displayed(raise_err=False)
+        approval_required.click()
+
+        approval_required_text = approval_required.text
+        print(f"已选择筛选条件: {approval_required_text}")
+
+        count = re.findall(r'\d+', approval_required_text)
+        if count:
+            count = int(count[0])
+            print(f"待审批的商品数量: {count}")
+            if count <= 0:
+                print(f"没有需要{filter_type}的商品了")
+                return sku_ls #"没有需要审批的商品了"
+        asin = "B0C7KT6ZZN"
+        search_input = self.tab.ele("xpath://kat-input[contains(@class,'SearchBox-module__searchInput')]").sr(
+            'xpath://span[@class="container"]//input[@part="input"]')
+        search_input.input(asin, clear=True)
+        search_btn = self.tab.ele("xpath://kat-icon[@name='search']")
+        search_btn.click()
+
+        for _ in range(3):
+            # 等待加载完成
+            load_ele = self.tab.ele("xpath://div[contains(@class,'Loader-module__loader')]")
+            load_ele.wait.deleted(timeout=3, raise_err=False)
+            time.sleep(0.5)
+            search_input = self.tab.ele("xpath://kat-input[contains(@class,'SearchBox-module__searchInput')]").sr(
+                'xpath://span[@class="container"]//input[@part="input"]')
+            search_input.input(asin, clear=True)
+            search_btn = self.tab.ele("xpath://kat-icon[@name='search']")
+            search_btn.click()
+
+            load_ele = self.tab.ele("xpath://div[contains(@class,'Loader-module__loader')]")
+            load_ele.wait.deleted(timeout=3, raise_err=False)
+            time.sleep(0.5)
+
+            sku_ls = self.tab.eles("xpath://div[@data-sku]",timeout=3)
+            if len(sku_ls) > 0:
+                break
+            approval_required.click()
+
+        return sku_ls
+
+    def wait_loaded(self):
+        # 等待加载完成
+        try:
+            load_ele = self.tab.ele(
+                'xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]//div[contains(@class,"Loader-module__loader")]|//kat-panel[@data-testid="kat-panel-ActionPanelContent"]/div[@data-f1-component]//div[contains(@class,"==")]/div[contains(@class,"==")]/span',
+                timeout=3)
+            load_ele.wait.deleted(timeout=5, raise_err=False)
+        except Exception as e:
+            print("等待加载中消失出错", e)
+    
+    def clear_tab(self):
+        all_tab = self.browser.get_tabs(title="亚马逊")
+        close_tab = []
+        for tab in all_tab:
+            tab_id = tab if isinstance(tab,str) else tab.tab_id
+            if self.tab.tab_id == tab:
+                continue
+            close_tab.append(tab)
+        print("需要关闭的标签页",close_tab)
+        print("当前操作的tab_id",self.tab.tab_id)
+        self.browser.close_tabs(close_tab)
+    
+    def handle_repair_product(self,tab:ChromiumTab):
+        def wait_loaded():
+            # 等待加载完成
+            try:
+                load_ele = tab.ele(
+                    'xpath://div[@class="contentWrapper"]//div[contains(@class,"==")]/span[not(node())]',
+                    timeout=3)
+                load_ele.wait.deleted(timeout=5, raise_err=False)
+            except Exception as e:
+                print("等待加载中消失出错", e)
+
+        tab.wait.doc_loaded(timeout=30)
+        submit_btn_ls = tab.eles('xpath://div[@id="ahd-product-policies-table"]/div//div[@data-testid="nextStepsMetricWrapper"]//kat-button[@label="提交"]',timeout=10)
+        if len(submit_btn_ls) == 0:
+            print("未找到提交按钮，可能页面未加载完成或者页面结构发生变化")
+            return
+        # todo 遍历
+        for index in range(len(submit_btn_ls)):
+            if index > len(submit_btn_ls)-1:
+                print("提交按钮数量发生变化，停止处理")
+                break
+            
+            submit_btn = submit_btn_ls[index]
+
+            # 关闭按钮
+            close_x_btn = tab.eles('xpath://div[@class="flyoutPanelContent"]/span',timeout=5)
+            if len(close_x_btn) > 0:
+                close_x_btn[0].wait.displayed(timeout=5, raise_err=False)
+                close_x_btn[0].click()
+
+            submit_btn.wait.enabled(timeout=5, raise_err=False)
+            submit_btn.click()
+            time.sleep(0.5)
+            self.wait_loaded()
+
+            wait_loaded()
+
+            need_input = tab.eles('xpath://div[@class="contentWrapper"]//kat-input[@data-testid="kat-input-dew:ump_epr_resgitration_number_title"]',timeout=5)
+            if len(need_input) > 0:
+                print("需要输入注册号，不符合操作要求，跳过...")
+                continue
+
+            target_title = tab.eles('xpath://div[@class="contentWrapper"]//section//h4[text()="警告和安全信息"]')
+            if len(target_title) > 0:
+                not_start = tab.eles('xpath://div[@class="contentWrapper"]//div[@aria-label="安全证明"]//kat-label[@text="未开始"]')
+                if len(not_start) == 0:
+                    print("安全证明-不是未开始状态，不需要操作")
+                    continue
+
+                not_start.wait.displayed(timeout=5, raise_err=False)
+                not_start.click()
+
+                wait_loaded()
+
+                check = tab.ele('xpath://div[@class="contentWrapper"]//kat-checkbox[@name="value"]')
+                check.wait.displayed(timeout=5, raise_err=False)
+                check.click()
+
+                save_btn = tab.ele('xpath://div[@class="contentWrapper"]//kat-button[@variant="primary"]')
+                save_btn.wait.enabled(timeout=5, raise_err=False)
+                save_btn.click()
+
+                wait_loaded()
+
+                close_btn = tab.ele('xpath://div[@class="contentWrapper"]//kat-button[@label="关闭"]',timeout=10)
+                close_btn.wait.displayed(timeout=5, raise_err=False)
+                close_btn.click()
+
+            save_btn_ls = tab.eles('xpath://div[@class="contentWrapper"]//kat-button[@variant="primary"]',timeout=5)
+            if len(save_btn_ls) > 0:
+                option_selection_ls = tab.eles('xpath://div[@class="contentWrapper"]//div[@role="option"]',timeout=5)
+                for option in option_selection_ls:
+                    option.click()
+                    time.sleep(0.5)
+
+                save_btn_ls[0].wait.enabled(timeout=5, raise_err=False)
+                save_btn_ls[0].click()
+
+                wait_loaded()
+
+                close_btn = tab.ele('xpath://div[@class="contentWrapper"]//kat-button[@label="关闭"]',timeout=10)
+                close_btn.wait.displayed(timeout=5, raise_err=False)
+                close_btn.wait.enabled(timeout=5, raise_err=False)
+                close_btn.click()
+
+            submit_btn_ls = tab.eles('xpath://div[@id="ahd-product-policies-table"]/div//div[@data-testid="nextStepsMetricWrapper"]//kat-button[@label="提交"]',timeout=10)
+
+        print("修复商品信息处理完成！")
+        tab.close()
+
+    def run_page_action(self):
+        print("开始执行")
+        num = 0
+        retry_num = 0
+        already_asin = set()
+
+        while retry_num < 3:  # 最多重试3次
+            # if num > 3:  #测试
+            #     return
+            # 等待加载完成
+            try:
+                load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]",timeout=5)
+                if len(load_ele) > 0:
+                    load_ele[0].wait.deleted(timeout=3, raise_err=False)
+                    time.sleep(0.5)
+
+                # 获取当前页码
+                try:
+                    page_pamel = self.tab.eles('xpath://kat-pagination',timeout=5)
+                    if len(page_pamel) > 0:
+                        current_page = page_pamel[0].sr('xpath:.//ul[@class="pages"]//li[@aria-current="true"]').text
+
+                        # 总页数
+                        total_page = page_pamel[0].sr.eles('xpath:.//ul[@class="pages"]//span[@class="page__inner"][last()]')
+                        if len(total_page) > 0:
+                            total_page = total_page[-1].text
+                        else:
+                            total_page = 0
+                        print(f"当前页码: {current_page} / 总页数: {total_page}")
+                except Exception as e:
+                    print("获取页码失败", e)
+
+
+                sku_ls = self.tab.eles("xpath://div[@data-sku]",timeout=10)
+                print(f"获取到 {len(sku_ls)}")
+                # for sku_ele in sku_ls[0:2]:
+                for sku_ele in sku_ls:
+                    # solve_problem = sku_ele.eles('xpath:.//kat-link[@label="解决商品信息问题"]')
+                    
+                    asin = sku_ele.ele('xpath:.//div[contains(@class,"JanusSplitBox-module__container")]//div[contains(@class,"JanusSplitBox-module__panel--") and contains(string(.),"ASIN")]/..//div[last()]').text
+                    print(f"ASIN {asin} 存在问题，正在点击解决...")
+                    if asin in already_asin:
+                        print(f"{asin} 已经处理过了，跳过")
+                        continue
+                    solve_problem = sku_ele.eles('xpath:.//kat-link[@label="解决商品信息问题"]|.//kat-link[@label="修复被禁止显示的商品"]|.//kat-link[@label="解决商品移除风险"]')
+                    if len(solve_problem) == 0:
+                        print(f"{asin},没有处理入口，不处理")
+                        yield (asin,"没有处理入口，不处理")
+                        already_asin.add(asin)
+                        continue
+
+                    solve_problem[0].click()
+
+                    action_panel = self.tab.ele('xpath://kat-panel-wrapper[@data-testid="kat-panel-wrapper-ActionPanelContent"]')
+                    action_panel.wait.displayed(timeout=5, raise_err=False)
+
+                    self.wait_loaded()
+
+                    try:
+                        # 如果存在“请求批准”按钮，则直接返回跳过
+                        request_approval_btn = self.tab.eles('xpath://kat-panel-wrapper[@data-testid="kat-panel-wrapper-ActionPanelContent"]//div[@data-testid="section-header" and contains(string(.),"移除")]',timeout=5)
+                        if len(request_approval_btn) > 0:
+                            print(f"ASIN {asin} 存在请求批准按钮，不需要处理,跳过...")
+                            panel_close_btn = self.tab.ele('xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]',
+                                                        timeout=5).sr('xpath:.//button[@class="close"]')
+                            panel_close_btn.click()
+
+                            action_panel.wait.deleted(timeout=3, raise_err=False)
+                            yield (asin,"请求批准")
+
+                        # 无需采取任何操作
+                        not_operate = self.tab.eles('xpath://kat-alert[contains(@description,"如果您之前已提交更改，则这些更改当前正在处理中") and not(@dismissed)]',timeout=3)
+                        if len(not_operate) > 0:
+                            print(f"ASIN {asin} 无需采取任何操作,跳过...")
+                            yield (asin,"无需操作")
+                            already_asin.add(asin)
+                            continue
+
+                        # 解决商品信息违规问题 按钮
+                        kat_box_ls = action_panel.eles('xpath:.//kat-box[@variant="white"]',timeout=5)
+                        # if len(kat_box_ls) == 0:
+                        #     print(f"ASIN {asin} 的操作面板中未找到选项，跳过...")
+                        #     continue
+                        print(f"ASIN {asin}需要处理的有：{len(kat_box_ls)}个问题.")
+                        # 解决商品信息违规问题 按钮，有多少个都要处理
+                        for i in range(len(kat_box_ls)):
+                            print(f"开始处理第{i}个问题")
+                            if len(kat_box_ls) <= i:
+                                print(f"ASIN {asin} 的操作面板中选项数量发生变化，停止处理...")
+                                break
+                            kat_box_ls[i].click()
+                            time.sleep(0.5)
+                            self.wait_loaded()
+
+                            # TODO 增加 “出现警告和安全信息时候下滑” 的情况
+                            safe_handle_ls = self.tab.eles('xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]//div[@aria-label="安全证明"]//kat-label[@text="未开始"]',
+                                                            timeout=5)
+                            if len(safe_handle_ls) > 0:
+                                print("存在安全证明，正在处理...")
+                                safe_handle_ls[0].click()
+                                time.sleep(0.5)
+                                self.wait_loaded()
+                                check_box = self.tab.ele('xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]//kat-checkbox')
+                                check_box.click()
+                            else:
+                                problem_selection_ls = self.tab.eles(
+                                    'xpath://kat-panel-wrapper[@data-testid="kat-panel-wrapper-ActionPanelContent"]//div[@data-testid="registry-list"]//div[@data-testid="registry"]',
+                                    timeout=10)
+                                print("待选择数量",len(problem_selection_ls))
+                                for problem_selection in problem_selection_ls:
+                                    problem_selection.click()
+                                    print("点击选择完成")
+                                    time.sleep(0.5)
+
+                            # 点击保存
+                            confirm_btn = self.tab.ele('xpath://kat-panel-wrapper[@data-testid="kat-panel-wrapper-ActionPanelContent"]//kat-button[@variant="primary"]')
+                            confirm_btn.wait.displayed(timeout=3, raise_err=False)
+                            confirm_btn.click()
+
+                            self.wait_loaded()
+
+                            # 等待关闭按钮出现
+                            try:
+                                close_btn = self.tab.ele('xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]//kat-button[@label="关闭"]',
+                                                            timeout=10)
+                                close_btn.click()
+                            except Exception as e:
+                                print("点击关闭按钮失败",e)
+
+                            kat_box_ls = action_panel.eles('xpath:.//kat-box[@variant="white"]', timeout=5)
+
+                        # 修复商品信息
+                        repair_product = action_panel.eles('xpath:.//kat-button[@class="action-button"]',timeout=5)
+                        if len(repair_product) > 0:
+                            print(f"ASIN {asin} 存在修复商品信息按钮，正在点击...")
+                            self.clear_tab()
+                            repair_product[0].click()
+                            time.sleep(1)
+                            # 获取最新的tab
+                            new_tab = self.browser.latest_tab
+                            if isinstance(new_tab, str):
+                                new_tab = self.browser.get_tab(id_or_num=new_tab)
+
+                            self.handle_repair_product(new_tab)
+                    except Exception as e:
+                        print("【asin】：",asin,"处理失败",traceback.format_exc())
+                        yield (asin,"处理失败")
+                        already_asin.add(asin)
+                        continue
+
+                    yield (asin,"处理完成")
+                    already_asin.add(asin)
+
+                    try:
+                        # 全部操作完成，关闭
+                        panel_close_btn= self.tab.ele('xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]',
+                                                        timeout=5).sr('xpath:.//button[@class="close"]')
+                        panel_close_btn.click()
+
+                        action_panel.wait.deleted(timeout=3, raise_err=False)
+
+                    except Exception as e:
+                        print("关闭操作面板失败", e)
+                
+                # 判断是否存在需要翻页的情况
+                page_pamel = self.tab.eles('xpath://kat-pagination',timeout=5)
+                if len(page_pamel) == 0:
+                    break
+                next_page_btn = page_pamel[0].sr('xpath:.//span[@part="pagination-nav-right"]')
+                class_str = next_page_btn.attr('class')
+                if "end" in class_str:
+                    break
+                next_page_btn.click()
+                num += 1
+                print(f"【程序计算】正在翻页，已翻 {num} 页...")
+
+                already_asin = set()
+
+            except Exception as e:
+                print("处理审批操作异常", e)
+                traceback.print_exc()
+                retry_num += 1
+                self.tab.refresh()
+                self.tab.wait.doc_loaded(raise_err=False,timeout=120)
+
+  
+
+
+class ApproveTask:
+    """审批任务处理类：负责处理产品风险审批任务"""
+    
+    country_info = {
+        "DE": "德国",
+        "FR": "法国",
+        "ES": "西班牙",
+        "IT": "意大利",
+        "UK": "英国"
+    }
+    
+    @staticmethod
+    def show_notification(message: str, message_type: str = "error"):
+        """显示 pywebview 顶层通知（5秒后自动消失）
+        
+        Args:
+            message: 通知消息
+            message_type: 消息类型 (success/warning/error/info)
+        """
+        if webview and webview.windows:
+            try:
+                # 转义单引号，防止 JavaScript 语法错误
+                safe_message = message.replace("'", "\\'").replace('"', '\\"').replace('\n', '\\n')
+                
+                # 设置通知样式颜色
+                color_map = {
+                    'success': '#67C23A',
+                    'warning': '#E6A23C',
+                    'error': '#F56C6C',
+                    'info': '#909399'
+                }
+                bg_color = color_map.get(message_type, '#F56C6C')
+                
+                # 构建前端通知的 JavaScript 代码 - 创建原生 HTML 通知
+                js_code = f"""
+                (function() {{
+                    // 移除已存在的通知
+                    var existingNotif = document.getElementById('pywebview-notification');
+                    if (existingNotif) {{
+                        existingNotif.remove();
+                    }}
+                    
+                    // 创建通知容器
+                    var notif = document.createElement('div');
+                    notif.id = 'pywebview-notification';
+                    notif.style.cssText = 'position: fixed; top: 20px; left: 50%; transform: translateX(-50%); ' +
+                        'background: {bg_color}; color: white; padding: 12px 20px; border-radius: 4px; ' +
+                        'box-shadow: 0 2px 12px rgba(0,0,0,0.3); z-index: 99999; font-size: 14px; ' +
+                        'max-width: 600px; word-wrap: break-word; display: flex; align-items: center; gap: 10px;';
+                    
+                    // 添加消息内容
+                    var msgSpan = document.createElement('span');
+                    msgSpan.textContent = '{safe_message}';
+                    notif.appendChild(msgSpan);
+                    
+                    // 添加关闭按钮
+                    var closeBtn = document.createElement('span');
+                    closeBtn.innerHTML = '×';
+                    closeBtn.style.cssText = 'cursor: pointer; font-size: 18px; font-weight: bold; margin-left: 10px;';
+                    closeBtn.onclick = function() {{ notif.remove(); }};
+                    notif.appendChild(closeBtn);
+                    
+                    // 添加到页面
+                    document.body.appendChild(notif);
+                    
+                    // 5秒后自动消失
+                    setTimeout(function() {{
+                        if (notif && notif.parentNode) {{
+                            notif.style.transition = 'opacity 0.3s';
+                            notif.style.opacity = '0';
+                            setTimeout(function() {{ notif.remove(); }}, 300);
+                        }}
+                    }}, 5000);
+                }})();
+                """
+                # 在第一个窗口中执行 JavaScript
+                webview.windows[0].evaluate_js(js_code)
+            except Exception as e:
+                print(f"显示通知失败: {str(e)}")
+    
+    """
+    处理流程：
+    1、解析任务json,提取对应的companyName 组组装user_info实例化 AmzoneApprove
+    2、打开对应的店铺、遍历所有的国家站点处理
+    3、切换至指定国家，切换至 管理所有库存页面
+    4、调用search方法，查询出是否存在需要审批的商品，如果没有则结束；如果有则进入处理流程
+    5、进入处理流程后，调用run_page_action方法(注意是通过yield 返回数据的)
+    
+    任务json示例：
+    {
+        "type": "product-risk-resolve-run",
+        "ts": 1775395996876,
+        "data": {
+            "taskId": 925,
+            "items": [
+                {
+                    "matched": true,
+                    "platform": "亚马逊",
+                    "shopName": "魏振峰",
+                    "shopId": "27543917795757",
+                    "companyName": "rongchuang123",
+                    "openStoreUrl": null,
+                    "matchedUserId": 17543915345493,
+                    "matchStatus": "MATCHED",
+                    "matchMessage": null
+                }
+            ],
+            "country_codes": [
+                "UK",
+                "DE",
+                "FR",
+                "ES"
+            ]
+        }
+    }
+    """
+    
+    def __init__(self, user_info: dict = None):
+        """初始化审批任务处理器
+        
+        Args:
+            user_info: 用户信息字典，包含 company, username, password
+        """
+        self.user_info = user_info or {}
+        self.running = True
+        
+    def log(self, message: str, level: str = "INFO"):
+        """日志输出
+        
+        Args:
+            message: 日志消息
+            level: 日志级别
+        """
+        from datetime import datetime
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        if level == "ERROR":
+            self.show_notification(message, "error")
+        print(f"[{timestamp}] [ApproveTask] [{level}] {message}")
+    
+    def process_task(self, task_data: dict):
+        """处理审批任务主入口
+        
+        Args:
+            task_data: 任务数据
+        """
+        try:
+            data = task_data.get("data", {})
+            task_id = data.get("taskId")
+            items = data.get("items", [])
+            country_codes = data.get("country_codes", [])
+            risk_listing_filter = data.get("risk_listing_filter", "")
+
+            if not task_id:
+                self.log("任务ID为空，跳过", "WARNING")
+                return
+            
+            if not items:
+                self.log("店铺列表为空，跳过", "WARNING")
+                return
+                
+            if not country_codes:
+                self.log("国家列表为空，跳过", "WARNING")
+                return
+            
+            self.log(f"开始处理审批任务 {task_id}，共 {len(items)} 个店铺，{len(country_codes)} 个国家")
+            
+            from config import runing_task
+            runing_task[task_id] = {
+                "status": "running",
+                "start_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "total_shops": len(items),
+                "processed_shops": 0,
+                "total_countries": len(country_codes) * len(items),
+                "processed_countries": 0,
+                "total_asins": 0,
+                "processed_asins": 0,
+                "success_count": 0,
+                "failed_count": 0,
+                "stop_requested": False
+            }
+            
+            # 遍历处理每个店铺
+            for idx, shop_item in enumerate(items, 1):
+                # 检查是否收到暂停请求
+                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
+                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理", "WARNING")
+                    runing_task[task_id]["status"] = "stopped"
+                    return
+                
+                shop_name = shop_item.get("shopName", "未知店铺")
+                self.log(f"[{idx}/{len(items)}] 开始处理店铺: {shop_name}")
+                self.show_notification(f"开始处理店铺: {shop_name}", "info")
+                
+                try:
+                    self.process_shop(shop_item, country_codes, task_id,risk_listing_filter)
+                    # 更新已处理店铺数
+                    if task_id in runing_task:
+                        runing_task[task_id]["processed_shops"] += 1
+                except Exception as e:
+                    import traceback
+                    self.log(f"处理店铺 {shop_name} 失败: {str(e)}", "ERROR")
+                    self.log(traceback.format_exc(), "ERROR")
+            
+            # 更新任务状态
+            if task_id in runing_task:
+                if runing_task[task_id].get("stop_requested", False):
+                    runing_task[task_id]["status"] = "stopped"
+                    self.log(f"任务 {task_id} 已被暂停！")
+                else:
+                    runing_task[task_id]["status"] = "completed"
+                    self.log(f"任务 {task_id} 处理完成！")
+            
+        except Exception as e:
+            import traceback
+            self.log(f"任务处理失败: {traceback.format_exc()}", "ERROR")
+            if task_id:
+                from config import runing_task
+                if task_id in runing_task:
+                    runing_task[task_id]["status"] = "failed"
+                    runing_task[task_id]["error"] = str(e)
+    
+    def process_shop(self, shop_item: dict, country_codes: list, task_id: int, risk_listing_filter: str):
+        """处理单个店铺
+        
+        Args:
+            shop_item: 店铺信息
+            country_codes: 国家代码列表
+            task_id: 任务ID
+            risk_listing_filter: 风险商品筛选条件
+        """
+        shop_name = shop_item.get("shopName", "未知店铺")
+        company_name = shop_item.get("companyName", "")
+
+        if not company_name:
+            self.log(f"店铺 {shop_name} 的公司名称为空，跳过", "WARNING")
+            return
+        
+
+        if task_id in runing_task:
+            runing_task[task_id]["current_shop"] = shop_name
+        
+        # 将店铺添加到正在执行中的店铺列表
+        start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        runing_shop[shop_name] = start_time
+        self.log(f"店铺 {shop_name} 已添加到执行列表，账号: {company_name}，开始时间: {start_time}")
+        
+        # 店铺打开重试最多3次
+        driver = None
+        max_retries = 3
+        
+        error_info = ""
+        for retry in range(max_retries):
+            try:
+                self.log(f"尝试打开店铺 {shop_name} (第 {retry + 1}/{max_retries} 次)")
+                
+                # 如果不是第一次尝试，先杀进程
+                # if retry > 0:
+                #     self.log("重试前先杀掉浏览器进程...")
+                #     kill_process("v6")
+                #     kill_process("v5")
+                #     time.sleep(2)
+                
+                # 组装用户信息并创建驱动
+                user_info = {
+                    **self.user_info,
+                    "company": company_name
+                }
+                driver = AmzoneApprove(user_info)
+                browser = driver.open_shop(shop_name)
+                
+                if browser and browser != "店铺不存在":
+                    self.log(f"成功打开店铺 {shop_name}")
+                    break
+                else:
+                    self.log(f"打开店铺失败: {browser}", "WARNING")
+                    driver = None
+
+                # 判断是否需要登录
+                need_login = driver.need_login()
+                if need_login:
+                    self.log(f"店铺 {shop_name} 需要登录，正在登录...")
+                    password = ""
+
+                    login_success = driver.login(password)
+                    if login_success:
+                        self.log(f"店铺 {shop_name} 登录成功，正在重新打开店铺...")
+                        browser = driver.open_shop(shop_name)
+                        if browser and browser != "店铺不存在":
+                            self.log(f"成功打开店铺 {shop_name} 登录后")
+                            break
+                        else:
+                            self.log(f"登录后打开店铺失败: {browser}", "WARNING")
+                            driver = None
+                    else:
+                        self.log(f"店铺 {shop_name} 登录失败", "WARNING")
+                        driver = None
+
+            except Exception as e:
+                import traceback
+                self.log(f"打开店铺异常: {traceback.format_exc()}", "INFO")
+                driver = None
+                error_info = str(e)
+                time.sleep(10)
+                
+            # 如果还有重试机会，等待后继续
+            if retry < max_retries - 1:
+                time.sleep(3)
+        
+        # 检查是否成功打开
+        if not driver or not browser or browser == "店铺不存在":
+            error_msg = f"店铺 {shop_name} 打开失败，已重试 {max_retries} 次，跳过该店铺,{error_info}"
+            self.log(error_msg, "ERROR")
+            # 从执行列表中移除
+            if shop_name in runing_shop:
+                del runing_shop[shop_name]
+            return
+        
+        try:
+            # 处理每个国家
+            for country_code in country_codes:
+                # 检查是否收到暂停请求
+                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
+                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理国家", "WARNING")
+                    break
+                
+                try:
+                    self.process_country(driver, country_code, task_id, shop_name,risk_listing_filter)
+                except Exception as e:
+                    import traceback
+                    self.log(f"处理国家 {country_code} 失败: {str(e)}", "ERROR")
+                    self.log(traceback.format_exc(), "ERROR")
+            # 最后回传，标记完成
+            try:
+                self.post_result(task_id, shop_name, country_code, "", "", is_done=True)
+            except Exception as e:
+                self.log(f"回传结果失败: {str(e)}", "ERROR")
+        finally:
+            # 关闭店铺
+            try:
+                if driver:
+                    self.log(f"关闭店铺 {shop_name}")
+                    driver.close_store()
+                    time.sleep(2)
+            except Exception as e:
+                self.log(f"关闭店铺失败: {str(e)}", "WARNING")
+            
+            # 从正在执行中的店铺列表中移除
+            if shop_name in runing_shop:
+                del runing_shop[shop_name]
+                self.log(f"店铺 {shop_name} 已从执行列表中移除")
+    
+    def process_country(self, driver: AmzoneApprove, country_code: str, task_id: int, shop_name: str, risk_listing_filter: str):
+        """处理单个国家的审批任务
+        
+        Args:
+            driver: AmzoneApprove驱动实例
+            country_code: 国家代码（如 UK, DE, FR 等）
+            task_id: 任务ID
+            shop_name: 店铺名称
+            risk_listing_filter: 风险商品筛选条件
+        """
+        from config import runing_task
+        
+        # 转换国家代码为中文名称
+        country_name = self.country_info.get(country_code, country_code)
+        info_mes = f"开始处理国家: {country_name} ({country_code})"
+        self.log(info_mes)
+        self.show_notification(info_mes, "info")
+        
+        # 更新当前处理的国家
+        if task_id in runing_task:
+            runing_task[task_id]["current_country"] = country_name
+        
+        # 切换国家，最多重试3次
+        max_retries = 3
+        switch_success = False
+        
+        for retry in range(max_retries):
+            try:
+                self.log(f"尝试切换到国家 {country_name} (第 {retry + 1}/{max_retries} 次)")
+                
+                # 如果不是第一次尝试，先刷新页面
+                if retry > 0:
+                    self.log("重试前刷新页面...")
+                    try:
+                        driver.tab.refresh()
+                        time.sleep(3)
+                    except Exception as e:
+                        self.log(f"刷新页面失败: {str(e)}", "WARNING")
+                
+                switch_success = driver.SwitchingCountries(country_name)
+                if switch_success:
+                    self.log(f"成功切换到国家 {country_name}")
+                    break
+                else:
+                    self.log(f"切换到国家 {country_name} 失败", "WARNING")
+                    
+            except Exception as e:
+                import traceback
+                self.log(f"切换国家 {country_name} 异常: {str(e)}", "ERROR")
+                self.log(traceback.format_exc(), "ERROR")
+                
+            # 如果还有重试机会，等待后继续
+            if retry < max_retries - 1:
+                time.sleep(2)
+        
+        # 如果切换失败，直接返回
+        if not switch_success:
+            error_message = f"切换到国家 {country_name} 失败，已重试 {max_retries} 次，跳过该国家"
+            self.log(error_message, "ERROR")
+            if task_id in runing_task:
+                runing_task[task_id]["processed_countries"] += 1
+            return
+        
+        # 切换到库存管理页面
+        try:
+            driver.SwitchPage()
+            self.log(f"已切换到库存管理页面")
+        except Exception as e:
+            import traceback
+            self.log(f"切换页面失败: {str(e)}", "ERROR")
+            self.log(traceback.format_exc(), "ERROR")
+            if task_id in runing_task:
+                runing_task[task_id]["processed_countries"] += 1
+            return
+        
+        # 搜索需要审批的商品，最多重试3次
+        sku_ls = []
+        for retry in range(max_retries):
+            try:
+                self.log(f"尝试搜索需要审批的商品 (第 {retry + 1}/{max_retries} 次)")
+                sku_ls = driver.search(filter_type=risk_listing_filter)
+                break
+            except Exception as e:
+                self.log(f"搜索商品异常: {str(e)}", "ERROR")
+                if retry < max_retries - 1:
+                    try:
+                        driver.tab.refresh()
+                        time.sleep(3)
+                    except Exception as refresh_error:
+                        self.log(f"刷新页面失败: {str(refresh_error)}", "WARNING")
+        
+        # 如果没有需要审批的商品，直接返回
+        if len(sku_ls) == 0:
+            self.log(f"国家 {country_name} 没有需要审批的商品")
+            if task_id in runing_task:
+                runing_task[task_id]["processed_countries"] += 1
+            return
+        
+        self.log(f"国家 {country_name} 有 {len(sku_ls)} 个需要审批的商品，开始处理...")
+        
+        # 处理所有需要审批的商品（通过yield获取结果）
+        try:
+            for asin, status in driver.run_page_action():
+                # 检查是否收到暂停请求
+                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
+                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理ASIN", "WARNING")
+                    break
+                
+                self.log(f"ASIN {asin} 处理结果: {status}")
+                
+                # 更新任务状态
+                if task_id in runing_task:
+                    runing_task[task_id]["current_asin"] = asin
+                    runing_task[task_id]["processed_asins"] += 1
+                    
+                    if status == "处理完成":
+                        runing_task[task_id]["success_count"] += 1
+                    elif status == "请求批准":
+                        # 请求批准的商品也算作成功（因为不需要处理）
+                        runing_task[task_id]["success_count"] += 1
+                    else:
+                        runing_task[task_id]["failed_count"] += 1
+                
+                # 回传结果到API
+                try:
+                    self.post_result(task_id, shop_name, country_code, asin, status)
+                except Exception as e:
+                    self.log(f"回传结果失败: {str(e)}", "ERROR")
+                    
+        except Exception as e:
+            import traceback
+            self.log(f"处理审批商品异常: {str(e)}", "ERROR")
+            self.log(traceback.format_exc(), "ERROR")
+        
+        # 更新已处理国家数
+        if task_id in runing_task:
+            runing_task[task_id]["processed_countries"] += 1
+        
+        self.log(f"国家 {country_name} 处理完成")
+    
+    def post_result(self, task_id: int, shop_name: str, country_code: str, asin: str, status: str,is_done: bool = False):
+        """回传处理结果到API
+        
+        Args:
+            task_id: 任务ID
+            shop_name: 店铺名称
+            country_code: 国家代码
+            asin: ASIN
+            status: 处理状态
+        """
+        import requests
+        from config import DELETE_BRAND_API_BASE
+        
+        url = f"{DELETE_BRAND_API_BASE}/api/product-risk-resolve/tasks/{task_id}/result"
+        if status == "请求批准":
+            country_data = {
+                            "status": "",
+                            "shopName": shop_name,
+                            "productAsinSku": "",
+                            "done": is_done,
+                            "removeAsin": asin,
+                            "removeStatus": status
+                        }
+        else:
+            country_data = {
+                            "status": status,
+                            "shopName": shop_name,
+                            "productAsinSku": asin,
+                            "done": is_done,
+                            "removeAsin": "",
+                            "removeStatus": ""
+                        }
+            
+        payload = {
+            "shops": [
+                {
+                    "error": "",
+                    "countries": {
+                        country_code : [ country_data ]
+                    },
+                    "shopName": shop_name
+                }
+            ]
+        }
+        
+        max_retries = 3
+        for retry in range(max_retries):
+            try:
+                print("=====================================")
+                self.log(f"尝试回传结果 (第 {retry + 1}/{max_retries} 次)")
+                self.log(f"回传URL: {url}")
+                self.log(f"回传数据: {payload}")
+                response = requests.post(
+                    url,
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                    timeout=30,
+                    verify=False
+                )
+                self.log(f"回传结果: {response.text}")
+                
+                if response.status_code == 200:
+                    self.log(f"结果回传成功: {asin} - {status}")
+                    return
+                else:
+                    self.log(f"结果回传失败，状态码: {response.status_code}", "WARNING")
+                print("=====================================")
+                    
+            except Exception as e:
+                self.log(f"调用API异常: {str(e)}", "ERROR")
+                print("=====================================")
+                
+            # 如果还有重试机会，等待后继续
+            if retry < max_retries - 1:
+                time.sleep(2)
+        
+        self.log(f"已达到最大重试次数，结果回传最终失败", "ERROR")
+        
+
+
+if __name__ == '__main__':
+    user_info = {
+        "company": "rongchuang123",
+        "username": "自动化_Robot",
+        "password": "#20zsg25"
+    }
+    shop_name = "魏振峰"
+    country = "西班牙"
+    kill_process('v6')
+    driver = AmzoneApprove(user_info)
+    browser = driver.open_shop(shop_name)
+    sw_suc = driver.SwitchingCountries(country)
+    driver.SwitchPage()
+    risk_listing_filter = "Active"
+    for _ in range(3):
+        try:
+            sku_ls = driver.search(filter_type=risk_listing_filter)
+            break
+        except Exception as e:
+            print(e)
+            driver.tab.refresh()
+    if len(sku_ls) > 0:
+        print("有数据，开始操作")
+        for asin, status in driver.run_page_action():
+            print(f"ASIN {asin} 的处理结果: {status}")
+        print("已完成操作")
+
+    # for i in range(0):
+    #     print(i)

app/amazon/approve.py

@@ -14,6 +14,7 @@ except ImportError:
     webview = None
 
 class AmzoneApprove(AmamzonBase):
+    mark_name = "产品风险审批"
 
     def SwitchPage(self):
         """
@@ -32,7 +33,6 @@ class AmzoneApprove(AmamzonBase):
         search_region = self.tab.ele('xpath://div[@id="searchBoxContainer"]//kat-input-group')
         search_region.wait.displayed(raise_err=False)
 
-
     def search(self,filter_type="ApprovalRequired"):
         sku_ls = []
 
@@ -70,8 +70,9 @@ class AmzoneApprove(AmamzonBase):
                 return sku_ls #"没有需要审批的商品了"
         for _ in range(3):
             # 等待加载完成
-            load_ele = self.tab.ele("xpath://div[contains(@class,'Loader-module__loader')]")
-            load_ele.wait.deleted(timeout=3, raise_err=False)
+            load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]")
+            if len(load_ele) > 0:
+                load_ele[0].wait.deleted(timeout=3, raise_err=False)
             time.sleep(0.5)
 
             sku_ls = self.tab.eles("xpath://div[@data-sku]",timeout=3)
@@ -91,9 +92,10 @@ class AmzoneApprove(AmamzonBase):
             print("等待加载中消失出错", e)
     
     def clear_tab(self):
-        all_tab = self.browser.get_tabs(title="亚马逊",as_id=True)
+        all_tab = self.browser.get_tabs(title="亚马逊")
         close_tab = []
         for tab in all_tab:
+            tab_id = tab if isinstance(tab,str) else tab.tab_id
             if self.tab.tab_id == tab:
                 continue
             close_tab.append(tab)
@@ -112,11 +114,13 @@ class AmzoneApprove(AmamzonBase):
             except Exception as e:
                 print("等待加载中消失出错", e)
 
-        tab.wait.doc_loaded(timeout=30)
+        tab.wait.doc_loaded(timeout=60,raise_err=False)
         submit_btn_ls = tab.eles('xpath://div[@id="ahd-product-policies-table"]/div//div[@data-testid="nextStepsMetricWrapper"]//kat-button[@label="提交"]',timeout=10)
         if len(submit_btn_ls) == 0:
             print("未找到提交按钮，可能页面未加载完成或者页面结构发生变化")
             return
+        for _ in range(3):
+            try:
                 # todo 遍历
                 for index in range(len(submit_btn_ls)):
                     if index > len(submit_btn_ls)-1:
@@ -187,6 +191,12 @@ class AmzoneApprove(AmamzonBase):
                         close_btn.click()
 
                     submit_btn_ls = tab.eles('xpath://div[@id="ahd-product-policies-table"]/div//div[@data-testid="nextStepsMetricWrapper"]//kat-button[@label="提交"]',timeout=10)
+                break
+            except Exception as e:
+                print(f"【handle_repair_product】处理修复商品信息异常", traceback.format_exc())
+                tab.refresh()
+                tab.wait.doc_loaded(timeout=60,raise_err=False)
+                time.sleep(2)
 
         print("修复商品信息处理完成！")
         tab.close()
@@ -194,42 +204,69 @@ class AmzoneApprove(AmamzonBase):
     def run_page_action(self):
         print("开始执行")
         num = 0
+        retry_num = 0
+        already_asin = set()
 
-        while 1:
+        while retry_num < 3:  # 最多重试3次
             # if num > 3:  #测试
             #     return
             # 等待加载完成
+            try:
                 load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]",timeout=5)
                 if len(load_ele) > 0:
                     load_ele[0].wait.deleted(timeout=3, raise_err=False)
                 time.sleep(0.5)
 
                 # 获取当前页码
+                try:
                     page_pamel = self.tab.eles('xpath://kat-pagination',timeout=5)
                     if len(page_pamel) > 0:
                         current_page = page_pamel[0].sr('xpath:.//ul[@class="pages"]//li[@aria-current="true"]').text
-                print(f"【current_page】开始处理，当前页码: {current_page}")
+
+                        # 总页数
+                        total_page = page_pamel[0].sr.eles('xpath:.//ul[@class="pages"]//span[@class="page__inner"][last()]')
+                        if len(total_page) > 0:
+                            total_page = total_page[-1].text
+                        else:
+                            total_page = 0
+                        print(f"当前页码: {current_page} / 总页数: {total_page}")
+                except Exception as e:
+                    print("获取页码失败", e)
+
 
                 sku_ls = self.tab.eles("xpath://div[@data-sku]",timeout=10)
                 print(f"获取到 {len(sku_ls)}")
                 # for sku_ele in sku_ls[0:2]:
                 for sku_ele in sku_ls:
                     # solve_problem = sku_ele.eles('xpath:.//kat-link[@label="解决商品信息问题"]')
-                solve_problem = sku_ele.eles('xpath:.//kat-link[@label="解决商品信息问题"]|.//kat-link[@label="修复被禁止显示的商品"]|.//kat-link[@label="解决商品移除风险"]')
-                if len(solve_problem) == 0:
-                    print(f"{asin},没有处理入口，不处理")
-                    yield (asin,"没有处理入口，不处理")
-                    continue
+                    
                     asin = sku_ele.ele('xpath:.//div[contains(@class,"JanusSplitBox-module__container")]//div[contains(@class,"JanusSplitBox-module__panel--") and contains(string(.),"ASIN")]/..//div[last()]').text
                     print(f"ASIN {asin} 存在问题，正在点击解决...")
-                solve_problem[0].click()
+                    if asin in already_asin:
+                        print(f"{asin} 已经处理过了，跳过")
+                        continue
+                    solve_problem = sku_ele.eles('xpath:.//kat-link[@label="解决商品信息问题"]|.//kat-link[@label="修复被禁止显示的商品"]|.//kat-link[@label="解决商品移除风险"]')
+                    if len(solve_problem) == 0:
+                        # //a[text0=”添加缺失的商品详情”]
+                        lack_info = sku_ele.eles('xpath:.//a[text()="添加缺失的商品详情"]')
+                        if len(lack_info) > 0:
+                            print(f"{asin} 需要添加缺失的商品详情，跳过...")
+                            yield (asin,"添加缺失的商品详情")
+                            continue
 
+                        print(f"{asin},没有处理入口，不处理")
+                        yield (asin,"没有处理入口，不处理")
+                        already_asin.add(asin)
+                        continue
+
+                    solve_problem[0].click()
 
                     action_panel = self.tab.ele('xpath://kat-panel-wrapper[@data-testid="kat-panel-wrapper-ActionPanelContent"]')
                     action_panel.wait.displayed(timeout=5, raise_err=False)
 
                     self.wait_loaded()
 
+                    try:
                         # 如果存在“请求批准”按钮，则直接返回跳过
                         request_approval_btn = self.tab.eles('xpath://kat-panel-wrapper[@data-testid="kat-panel-wrapper-ActionPanelContent"]//div[@data-testid="section-header" and contains(string(.),"移除")]',timeout=5)
                         if len(request_approval_btn) > 0:
@@ -240,7 +277,16 @@ class AmzoneApprove(AmamzonBase):
 
                             action_panel.wait.deleted(timeout=3, raise_err=False)
                             yield (asin,"请求批准")
+                            already_asin.add(asin)
+                            continue
 
+                        # 无需采取任何操作
+                        not_operate = self.tab.eles('xpath://kat-alert[contains(@description,"如果您之前已提交更改，则这些更改当前正在处理中") and not(@dismissed)]',timeout=3)
+                        if len(not_operate) > 0:
+                            print(f"ASIN {asin} 无需采取任何操作,跳过...")
+                            yield (asin,"无需操作")
+                            already_asin.add(asin)
+                            continue
 
                         # 解决商品信息违规问题 按钮
                         kat_box_ls = action_panel.eles('xpath:.//kat-box[@variant="white"]',timeout=5)
@@ -251,6 +297,9 @@ class AmzoneApprove(AmamzonBase):
                         # 解决商品信息违规问题 按钮，有多少个都要处理
                         for i in range(len(kat_box_ls)):
                             print(f"开始处理第{i}个问题")
+                            if len(kat_box_ls) <= i:
+                                print(f"ASIN {asin} 的操作面板中选项数量发生变化，停止处理...")
+                                break
                             kat_box_ls[i].click()
                             time.sleep(0.5)
                             self.wait_loaded()
@@ -305,8 +354,16 @@ class AmzoneApprove(AmamzonBase):
                                 new_tab = self.browser.get_tab(id_or_num=new_tab)
 
                             self.handle_repair_product(new_tab)
+                    except Exception as e:
+                        print("【asin】：",asin,"处理失败",traceback.format_exc())
+                        yield (asin,"处理失败")
+                        already_asin.add(asin)
+                        continue
 
                     yield (asin,"处理完成")
+                    already_asin.add(asin)
+
+                    try:
                         # 全部操作完成，关闭
                         panel_close_btn= self.tab.ele('xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]',
                                                         timeout=5).sr('xpath:.//button[@class="close"]')
@@ -314,6 +371,10 @@ class AmzoneApprove(AmamzonBase):
 
                         action_panel.wait.deleted(timeout=3, raise_err=False)
 
+                        self.clear_tab()
+
+                    except Exception as e:
+                        print("关闭操作面板失败", e)
                 
                 # 判断是否存在需要翻页的情况
                 page_pamel = self.tab.eles('xpath://kat-pagination',timeout=5)
@@ -325,11 +386,23 @@ class AmzoneApprove(AmamzonBase):
                     break
                 next_page_btn.click()
                 num += 1
-            # print(f"正在翻页，已翻 {num} 页...")
+                print(f"【程序计算】正在翻页，已翻 {num} 页...")
+
+                already_asin = set()
+
+            except Exception as e:
+                print("处理审批操作异常", e)
+                traceback.print_exc()
+                retry_num += 1
+                self.tab.refresh()
+                self.tab.wait.doc_loaded(raise_err=False,timeout=120)
+
+  
 
 
 class ApproveTask:
     """审批任务处理类：负责处理产品风险审批任务"""
+    mark_name = "产品风险审批"
     
     country_info = {
         "DE": "德国",
@@ -578,6 +651,7 @@ class ApproveTask:
         driver = None
         max_retries = 3
         
+        error_info = ""
         for retry in range(max_retries):
             try:
                 self.log(f"尝试打开店铺 {shop_name} (第 {retry + 1}/{max_retries} 次)")
@@ -603,13 +677,33 @@ class ApproveTask:
                 else:
                     self.log(f"打开店铺失败: {browser}", "WARNING")
                     driver = None
+
                 # 判断是否需要登录
+                need_login = driver.need_login()
+                if need_login:
+                    self.log(f"店铺 {shop_name} 需要登录，正在登录...")
+                    password = ""
+
+                    login_success = driver.login(password)
+                    if login_success:
+                        self.log(f"店铺 {shop_name} 登录成功，正在重新打开店铺...")
+                        browser = driver.open_shop(shop_name)
+                        if browser and browser != "店铺不存在":
+                            self.log(f"成功打开店铺 {shop_name} 登录后")
+                            break
+                        else:
+                            self.log(f"登录后打开店铺失败: {browser}", "WARNING")
+                            driver = None
+                    else:
+                        self.log(f"店铺 {shop_name} 登录失败", "WARNING")
+                        driver = None
 
             except Exception as e:
                 import traceback
-                self.log(f"打开店铺异常: {str(e)}", "ERROR")
-                self.log(traceback.format_exc(), "ERROR")
+                self.log(f"打开店铺异常: {traceback.format_exc()}", "INFO")
                 driver = None
+                error_info = str(e)
+                time.sleep(10)
                 
             # 如果还有重试机会，等待后继续
             if retry < max_retries - 1:
@@ -617,7 +711,7 @@ class ApproveTask:
         
         # 检查是否成功打开
         if not driver or not browser or browser == "店铺不存在":
-            error_msg = f"店铺 {shop_name} 打开失败，已重试 {max_retries} 次，跳过该店铺"
+            error_msg = f"店铺 {shop_name} 打开失败，已重试 {max_retries} 次，跳过该店铺,{error_info}"
             self.log(error_msg, "ERROR")
             # 从执行列表中移除
             if shop_name in runing_shop:
@@ -775,7 +869,7 @@ class ApproveTask:
                     
                     if status == "处理完成":
                         runing_task[task_id]["success_count"] += 1
-                    elif status == "请求批准":
+                    elif status in ["请求批准", "添加缺失的商品详情"]:
                         # 请求批准的商品也算作成功（因为不需要处理）
                         runing_task[task_id]["success_count"] += 1
                     else:
@@ -812,7 +906,7 @@ class ApproveTask:
         from config import DELETE_BRAND_API_BASE
         
         url = f"{DELETE_BRAND_API_BASE}/api/product-risk-resolve/tasks/{task_id}/result"
-        if status == "请求批准":
+        if status in ["请求批准","添加缺失的商品详情"]:
             country_data = {
                             "status": "",
                             "shopName": shop_name,

app/amazon/del_brand.py

@@ -221,13 +221,47 @@ class ZiniaoDriver:
             # 端口未启动，继续执行启动操作
             print(f"端口 {self.socket_port} 未启动，开始启动客户端")
 
+        self.kill_process('v6')
+        time.sleep(5)
         self.client_path = self.get_zinaio_exe("superbrowserv6").strip('"')
         print(self.client_path)
         cmd = [self.client_path, '--run_type=web_driver', '--ipc_type=http',
                '--port=' + str(self.socket_port)]
         print(" ".join(cmd))
+        
+        # 最大重试次数
+        max_retries = 3
+        
+        for retry_count in range(max_retries):
+            print(f"第 {retry_count + 1} 次尝试启动客户端...")
+            
+            # 启动进程
             subprocess.Popen(cmd)
-        time.sleep(5)
+            
+            # 循环检测10秒，每0.5秒检测一次
+            start_check_time = time.time()
+            client_started = False
+            
+            while time.time() - start_check_time < 10:
+                try:
+                    response = requests.get(url, timeout=2)
+                    print(f"客户端启动成功！(第 {retry_count + 1} 次尝试)")
+                    client_started = True
+                    break
+                except (requests.exceptions.ConnectionError, requests.exceptions.Timeout):
+                    # 端口还未启动，继续等待
+                    time.sleep(0.5)
+            
+            if client_started:
+                time.sleep(5)  # 等待客户端完全启动
+                # 更新内核
+                self.update_core()
+                return
+            else:
+                print(f"第 {retry_count + 1} 次尝试启动失败，10秒内未检测到客户端启动")
+        
+        # 超过最大重试次数，抛出异常
+        raise RuntimeError(f"客户端启动失败：重试 {max_retries} 次后仍未成功启动")
 
     def open_shop(self, shop_name: str):
         """
@@ -242,8 +276,7 @@ class ZiniaoDriver:
         # 启动客户端
         self.start_client()
 
-        # 更新内核
-        self.update_core()
+
 
         # 获取店铺列表
         shop_ls = self.get_browser_list()
@@ -381,11 +414,12 @@ class AmamzonBase(ZiniaoDriver):
 
             # 获取当前标签页
             tab = self.tab
+            tab.wait.doc_loaded(timeout=120,raise_err=False)
 
             # 步骤1：获取当前国家名称
             print(f"正在检查当前国家...")
             current_country_ele = tab.ele('xpath://div[@class="dropdown-account-switcher-header-label"]/span[last()]',
-                                          timeout=10)
+                                          timeout=20)
             if current_country_ele:
                 current_country = current_country_ele.text.strip()
                 print(f"当前国家：{current_country}")

app/amazon/main.py

@@ -7,6 +7,7 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from config import JSON_TASK_QUEUE, runing_task, runing_shop, DELETE_BRAND_API_BASE, ZN_COMPANY, ZN_USERNAME, ZN_PASSWORD
 from amazon.del_brand import AmazoneDriver, kill_process
 from amazon.approve import ApproveTask
+from amazon.match_action import MatchTak
 
 
 class TaskMonitor:
@@ -47,6 +48,10 @@ class TaskMonitor:
         self.executor = ThreadPoolExecutor(max_workers=self.max_workers)
         futures = []  # 保存所有提交的任务Future对象
         
+        task_type_info = {
+            "product-risk-resolve-run" : "产品风险审批",
+            "shop-match-run" : "匹配价格"
+        }
         try:
             while self.running:
                 try:
@@ -63,10 +68,10 @@ class TaskMonitor:
                         future = self.executor.submit(self._process_task_wrapper, task_data)
                         futures.append(future)
                         
-                    elif task_type == "product-risk-resolve-run":
+                    elif task_type in task_type_info:
                         # 提交产品风险审批任务到线程池
                         self.log(f"接收到产品风险审批任务，提交到线程池处理...")
-                        future = self.executor.submit(self._process_approve_task_wrapper, task_data)
+                        future = self.executor.submit(self._process_approve_task_wrapper, task_data, task_type_info[task_type])
                         futures.append(future)
                         
                     else:
@@ -102,16 +107,21 @@ class TaskMonitor:
         except Exception as e:
             self.log(f"线程 {id(task_data)} 删除品牌任务处理异常: {traceback.format_exc()}", "ERROR")
     
-    def _process_approve_task_wrapper(self, task_data: Dict[str, Any]):
+    def _process_approve_task_wrapper(self, task_data: Dict[str, Any],TASK_TYPE:str):
         """审批任务处理包装器（用于线程池调用）
         
         Args:
             task_data: 任务数据
         """
         try:
+            TASK_INFO = {
+                "产品风险审批" : ApproveTask,
+                "匹配价格" : MatchTak
+            }
             self.log(f"线程 {id(task_data)} 开始处理产品风险审批任务...")
             # 创建ApproveTask实例并处理任务
-            approve_task = ApproveTask(user_info=self.user_info)
+            TASK_CLS = TASK_INFO[TASK_TYPE]  # 根据任务类型选择处理类，默认为ApproveTask
+            approve_task = TASK_CLS(user_info=self.user_info)
             approve_task.process_task(task_data)
             self.log(f"线程 {id(task_data)} 产品风险审批任务处理完成")
         except Exception as e:
@@ -232,24 +242,24 @@ class TaskMonitor:
                     driver = None
                 
                 # 判断是否需要登录
-                # need_login = driver.need_login()
-                # if need_login:
-                #     self.log(f"店铺 {shop_name} 需要登录，正在登录...")
-                #     password = ""
+                need_login = driver.need_login()
+                if need_login:
+                    self.log(f"店铺 {shop_name} 需要登录，正在登录...")
+                    password = ""
 
-                #     login_success = driver.login(password)
-                #     if login_success:
-                #         self.log(f"店铺 {shop_name} 登录成功，正在重新打开店铺...")
-                #         browser = driver.open_shop(shop_name)
-                #         if browser and browser != "店铺不存在":
-                #             self.log(f"成功打开店铺 {shop_name} 登录后")
-                #             break
-                #         else:
-                #             self.log(f"登录后打开店铺失败: {browser}", "WARNING")
-                #             driver = None
-                #     else:
-                #         self.log(f"店铺 {shop_name} 登录失败", "WARNING")
-                #         driver = None
+                    login_success = driver.login(password)
+                    if login_success:
+                        self.log(f"店铺 {shop_name} 登录成功，正在重新打开店铺...")
+                        browser = driver.open_shop(shop_name)
+                        if browser and browser != "店铺不存在":
+                            self.log(f"成功打开店铺 {shop_name} 登录后")
+                            break
+                        else:
+                            self.log(f"登录后打开店铺失败: {browser}", "WARNING")
+                            driver = None
+                    else:
+                        self.log(f"店铺 {shop_name} 登录失败", "WARNING")
+                        driver = None
                 
                     
             except Exception as e:

app/amazon/match_action.py

@@ -0,0 +1,656 @@
+import time
+import re
+import traceback
+from DrissionPage._pages.chromium_tab import ChromiumTab
+
+from config import runing_task, runing_shop
+from datetime import datetime
+from amazon.del_brand import AmamzonBase, kill_process
+
+from amazon.tool import show_notification
+
+
+class AmzoneMatchAction(AmamzonBase):
+    mark_name = "匹配价格"
+
+    def SwitchPage(self):
+        """
+        切换至 管理所有库存页面
+        1、等待 //navigation-favorites-bar[@class="hydrated"] 出现
+        """
+        navigation = self.tab.ele('xpath://navigation-favorites-bar[@class="hydrated"]')
+        navigation.wait.displayed(raise_err=False)
+        page_btn = navigation.sr('xpath://internal-fav-bar-links[@data-internal="navigation"]').sr(
+            'xpath://a[@data-page-id="ezdpc-gui-inventory-mons"]')
+        page_btn.wait.displayed(raise_err=False)
+        page_btn.click(timeout=5)
+
+        self.tab.wait.doc_loaded()
+        # 等待搜索框出现
+        search_region = self.tab.ele('xpath://div[@id="searchBoxContainer"]//kat-input-group')
+        search_region.wait.displayed(raise_err=False)
+
+    def search(self,filter_type="ApprovalRequired"):
+        sku_ls = []
+
+        load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]",timeout=5)
+        if len(load_ele) > 0:
+            load_ele[0].wait.deleted(timeout=3, raise_err=False)
+        time.sleep(0.5)
+
+        drop_down = self.tab.ele('xpath://div[contains(@class,"VolusListingStatusDropDown-module__verticalContainer")]//kat-dropdown')
+        drop_down.wait.displayed(raise_err=False)
+        drop_down.wait.enabled(raise_err=False)
+        time.sleep(0.6)
+        drop_down.click()
+        # //kat-option[@value="SearchSuppressed"]
+        xp = f'xpath://kat-option[@value="{filter_type}"]'
+        print(f"【{self.mark_name}】正在寻找筛选条件 {filter_type}，xpath: {xp}")
+        approval_required = self.tab.eles(xp,timeout=5)
+        if len(approval_required) == 0:
+            print(f"【{self.mark_name}】没有需要{filter_type}选项】没有需要{filter_type}的商品了")
+            return sku_ls  # "没有需要审批的商品了"
+        else:
+            approval_required = approval_required[0]
+        approval_required.wait.displayed(raise_err=False)
+        approval_required.click()
+
+        approval_required_text = approval_required.text
+        print(f"【{self.mark_name}】已选择筛选条件: {approval_required_text}")
+
+        count = re.findall(r'\d+', approval_required_text)
+        if count:
+            count = int(count[0])
+            print(f"【{self.mark_name}】待审批的商品数量: {count}")
+            if count <= 0:
+                print(f"【{self.mark_name}】没有需要{filter_type}的商品了")
+                return sku_ls #"没有需要审批的商品了"
+        for _ in range(3):
+            # 等待加载完成
+            load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]")
+            if len(load_ele) > 0:
+                load_ele[0].wait.deleted(timeout=3, raise_err=False)
+            time.sleep(0.5)
+
+            sku_ls = self.tab.eles("xpath://div[@data-sku]",timeout=3)
+            if len(sku_ls) > 0:
+                break
+            approval_required.click()
+        return sku_ls
+
+    def wait_loaded(self):
+        # 等待加载完成
+        try:
+            load_ele = self.tab.ele(
+                'xpath://kat-panel[@data-testid="kat-panel-ActionPanelContent"]//div[contains(@class,"Loader-module__loader")]|//kat-panel[@data-testid="kat-panel-ActionPanelContent"]/div[@data-f1-component]//div[contains(@class,"==")]/div[contains(@class,"==")]/span',
+                timeout=3)
+            load_ele.wait.deleted(timeout=5, raise_err=False)
+        except Exception as e:
+            print(f"【{self.mark_name}】等待加载中消失出错", e)  
+    
+    def run_page_action(self):
+        print(f"【{self.mark_name}】开始执行")
+        num = 0
+        retry_num = 0
+        already_asin = set()
+
+        while retry_num < 3:  # 最多重试3次
+            # if num > 3:  #测试
+            #     return
+            # 等待加载完成
+            try:
+                load_ele = self.tab.eles("xpath://div[contains(@class,'Loader-module__loader')]",timeout=5)
+                if len(load_ele) > 0:
+                    load_ele[0].wait.deleted(timeout=3, raise_err=False)
+                time.sleep(0.5)
+
+                # 获取当前页码
+                try:
+                    page_pamel = self.tab.eles('xpath://kat-pagination',timeout=5)
+                    if len(page_pamel) > 0:
+                        current_page = page_pamel[0].sr('xpath:.//ul[@class="pages"]//li[@aria-current="true"]').text
+
+                        # 总页数
+                        total_page = page_pamel[0].sr.eles('xpath:.//ul[@class="pages"]//span[@class="page__inner"][last()]')
+                        if len(total_page) > 0:
+                            total_page = total_page[-1].text
+                        else:
+                            total_page = 0
+                        print(f"【{self.mark_name}】当前页码: {current_page} / 总页数: {total_page}")
+                except Exception as e:
+                    print(f"【{self.mark_name}】获取页码失败", e)
+
+
+                sku_ls = self.tab.eles("xpath://div[@data-sku]",timeout=10)
+                print(f"【{self.mark_name}】获取到 {len(sku_ls)}")
+                # for sku_ele in sku_ls[0:2]:
+                for sku_ele in sku_ls:
+                    # solve_problem = sku_ele.eles('xpath:.//kat-link[@label="解决商品信息问题"]')
+                    
+                    asin = sku_ele.ele('xpath:.//div[contains(@class,"JanusSplitBox-module__container")]//div[contains(@class,"JanusSplitBox-module__panel--") and contains(string(.),"ASIN")]/..//div[last()]').text
+                    print(f"【{self.mark_name}】ASIN {asin} 找到....")
+                    if asin in already_asin:
+                        print(f"【{self.mark_name}】{asin} 已经处理过了，跳过")
+                        continue
+
+                    price_match = sku_ele.eles('xpath:.//div[@data-test-id="FeaturedOfferPrice"]//a[text()="匹配"]')
+                    if len(price_match) == 0:
+                        print(f"【{self.mark_name}】{asin},没有推荐价格匹配按钮")
+                        yield (asin,"无需处理")
+                        already_asin.add(asin)
+                        continue
+                    try:
+                        price_match[0].click()
+
+                        save_all_btn = self.tab.ele('xpath://kat-button[@label="保存所有"]',timeout=10)
+                        save_all_btn.wait.displayed(timeout=10, raise_err=False)
+                        save_all_btn.click()
+
+                        save_all_btn.wait.deleted(timeout=10, raise_err=False)
+
+                        yield (asin,"处理完成")
+                        already_asin.add(asin)
+                    except Exception as e:
+                        print(f"{asin} 处理失败", e)
+                        yield (asin,"处理失败")
+                        already_asin.add(asin)
+                        continue
+
+                
+                # 判断是否存在需要翻页的情况
+                page_pamel = self.tab.eles('xpath://kat-pagination',timeout=5)
+                if len(page_pamel) == 0:
+                    break
+                next_page_btn = page_pamel[0].sr('xpath:.//span[@part="pagination-nav-right"]')
+                class_str = next_page_btn.attr('class')
+                if "end" in class_str:
+                    break
+                next_page_btn.click()
+                num += 1
+                print(f"【{self.mark_name}】【程序计算】正在翻页，已翻 {num} 页...")
+
+                already_asin = set()
+
+            except Exception as e:
+                print(f"【{self.mark_name}】处理匹配操作异常", e)
+                traceback.print_exc()
+                retry_num += 1
+                self.tab.refresh()
+                self.tab.wait.doc_loaded(raise_err=False,timeout=120)
+
+  
+
+class MatchTak:
+
+    country_info = {
+        "DE": "德国",
+        "FR": "法国",
+        "ES": "西班牙",
+        "IT": "意大利",
+        "UK": "英国"
+    }
+    
+
+    def __init__(self, user_info: dict = None):
+        """初始化审批任务处理器
+        
+        Args:
+            user_info: 用户信息字典，包含 company, username, password
+        """
+        self.user_info = user_info or {}
+        self.running = True
+
+    def log(self, message: str, level: str = "INFO"):
+        """日志输出
+        
+        Args:
+            message: 日志消息
+            level: 日志级别
+        """
+        from datetime import datetime
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        if level == "ERROR":
+            show_notification(message, "error")
+        print(f"[{timestamp}] [MatchTak] [{level}] {message}")
+
+
+    def process_task(self, task_data: dict):
+        """处理审批任务主入口
+        
+        Args:
+            task_data: 任务数据
+        """
+        try:
+            data = task_data.get("data", {})
+            task_id = data.get("taskId")
+            items = data.get("items", [])
+            country_codes = data.get("country_codes", [])
+            risk_listing_filter = data.get("risk_listing_filter", "All")
+
+            if not task_id:
+                self.log("任务ID为空，跳过", "WARNING")
+                return
+            
+            if not items:
+                self.log("店铺列表为空，跳过", "WARNING")
+                return
+                
+            if not country_codes:
+                self.log("国家列表为空，跳过", "WARNING")
+                return
+            
+            self.log(f"开始处理审批任务 {task_id}，共 {len(items)} 个店铺，{len(country_codes)} 个国家")
+            
+            from config import runing_task
+            runing_task[task_id] = {
+                "status": "running",
+                "start_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                "total_shops": len(items),
+                "processed_shops": 0,
+                "total_countries": len(country_codes) * len(items),
+                "processed_countries": 0,
+                "total_asins": 0,
+                "processed_asins": 0,
+                "success_count": 0,
+                "failed_count": 0,
+                "stop_requested": False
+            }
+            
+            # 遍历处理每个店铺
+            for idx, shop_item in enumerate(items, 1):
+                # 检查是否收到暂停请求
+                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
+                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理", "WARNING")
+                    runing_task[task_id]["status"] = "stopped"
+                    return
+                
+                shop_name = shop_item.get("shopName", "未知店铺")
+                self.log(f"[{idx}/{len(items)}] 开始处理店铺: {shop_name}")
+                show_notification(f"开始处理店铺: {shop_name}", "info")
+                
+                try:
+                    self.process_shop(shop_item, country_codes, task_id,risk_listing_filter)
+                    # 更新已处理店铺数
+                    if task_id in runing_task:
+                        runing_task[task_id]["processed_shops"] += 1
+                except Exception as e:
+                    import traceback
+                    self.log(f"处理店铺 {shop_name} 失败: {str(e)}", "ERROR")
+                    self.log(traceback.format_exc(), "ERROR")
+            
+            # 更新任务状态
+            if task_id in runing_task:
+                if runing_task[task_id].get("stop_requested", False):
+                    runing_task[task_id]["status"] = "stopped"
+                    self.log(f"任务 {task_id} 已被暂停！")
+                else:
+                    runing_task[task_id]["status"] = "completed"
+                    self.log(f"任务 {task_id} 处理完成！")
+            
+        except Exception as e:
+            import traceback
+            self.log(f"任务处理失败: {traceback.format_exc()}", "ERROR")
+            if task_id:
+                from config import runing_task
+                if task_id in runing_task:
+                    runing_task[task_id]["status"] = "failed"
+                    runing_task[task_id]["error"] = str(e)
+    
+    def process_shop(self, shop_item: dict, country_codes: list, task_id: int, risk_listing_filter: str):
+        """处理单个店铺
+        
+        Args:
+            shop_item: 店铺信息
+            country_codes: 国家代码列表
+            task_id: 任务ID
+            risk_listing_filter: 风险商品筛选条件
+        """
+        shop_name = shop_item.get("shopName", "未知店铺")
+        company_name = shop_item.get("companyName", "")
+
+        if not company_name:
+            self.log(f"店铺 {shop_name} 的公司名称为空，跳过", "WARNING")
+            return
+        
+
+        if task_id in runing_task:
+            runing_task[task_id]["current_shop"] = shop_name
+        
+        # 将店铺添加到正在执行中的店铺列表
+        start_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        runing_shop[shop_name] = start_time
+        self.log(f"店铺 {shop_name} 已添加到执行列表，账号: {company_name}，开始时间: {start_time}")
+        
+        # 店铺打开重试最多3次
+        driver = None
+        max_retries = 3
+        
+        error_info = ""
+        for retry in range(max_retries):
+            try:
+                self.log(f"尝试打开店铺 {shop_name} (第 {retry + 1}/{max_retries} 次)")
+                
+                # 如果不是第一次尝试，先杀进程
+                # if retry > 0:
+                #     self.log("重试前先杀掉浏览器进程...")
+                #     kill_process("v6")
+                #     kill_process("v5")
+                #     time.sleep(2)
+                
+                # 组装用户信息并创建驱动
+                user_info = {
+                    **self.user_info,
+                    "company": company_name
+                }
+                driver = AmzoneMatchAction(user_info)
+                browser = driver.open_shop(shop_name)
+                
+                if browser and browser != "店铺不存在":
+                    self.log(f"成功打开店铺 {shop_name}")
+                    break
+                else:
+                    self.log(f"打开店铺失败: {browser}", "WARNING")
+                    driver = None
+
+                # 判断是否需要登录
+                need_login = driver.need_login()
+                if need_login:
+                    self.log(f"店铺 {shop_name} 需要登录，正在登录...")
+                    password = ""
+
+                    login_success = driver.login(password)
+                    if login_success:
+                        self.log(f"店铺 {shop_name} 登录成功，正在重新打开店铺...")
+                        browser = driver.open_shop(shop_name)
+                        if browser and browser != "店铺不存在":
+                            self.log(f"成功打开店铺 {shop_name} 登录后")
+                            break
+                        else:
+                            self.log(f"登录后打开店铺失败: {browser}", "WARNING")
+                            driver = None
+                    else:
+                        self.log(f"店铺 {shop_name} 登录失败", "WARNING")
+                        driver = None
+
+            except Exception as e:
+                import traceback
+                self.log(f"打开店铺异常: {traceback.format_exc()}", "INFO")
+                driver = None
+                error_info = str(e)
+                time.sleep(10)
+                
+            # 如果还有重试机会，等待后继续
+            if retry < max_retries - 1:
+                time.sleep(3)
+        
+        # 检查是否成功打开
+        if not driver or not browser or browser == "店铺不存在":
+            error_msg = f"店铺 {shop_name} 打开失败，已重试 {max_retries} 次，跳过该店铺,{error_info}"
+            self.log(error_msg, "ERROR")
+            # 从执行列表中移除
+            if shop_name in runing_shop:
+                del runing_shop[shop_name]
+            return
+        
+        try:
+            # 处理每个国家
+            for country_code in country_codes:
+                # 检查是否收到暂停请求
+                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
+                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理国家", "WARNING")
+                    break
+                
+                try:
+                    self.process_country(driver, country_code, task_id, shop_name,risk_listing_filter)
+                except Exception as e:
+                    import traceback
+                    self.log(f"处理国家 {country_code} 失败: {str(e)}", "ERROR")
+                    self.log(traceback.format_exc(), "ERROR")
+            # 最后回传，标记完成
+            try:
+                self.post_result(task_id, shop_name, country_code, "", "", is_done=True)
+            except Exception as e:
+                self.log(f"回传结果失败: {str(e)}", "ERROR")
+        finally:
+            # 关闭店铺
+            try:
+                if driver:
+                    self.log(f"关闭店铺 {shop_name}")
+                    driver.close_store()
+                    time.sleep(2)
+            except Exception as e:
+                self.log(f"关闭店铺失败: {str(e)}", "WARNING")
+            
+            # 从正在执行中的店铺列表中移除
+            if shop_name in runing_shop:
+                del runing_shop[shop_name]
+                self.log(f"店铺 {shop_name} 已从执行列表中移除")
+    
+    def process_country(self, driver: AmzoneMatchAction, country_code: str, task_id: int, shop_name: str, risk_listing_filter: str):
+        """处理单个国家的审批任务
+        
+        Args:
+            driver: AmzoneApprove驱动实例
+            country_code: 国家代码（如 UK, DE, FR 等）
+            task_id: 任务ID
+            shop_name: 店铺名称
+            risk_listing_filter: 风险商品筛选条件
+        """
+        from config import runing_task
+        
+        # 转换国家代码为中文名称
+        country_name = self.country_info.get(country_code, country_code)
+        info_mes = f"开始处理国家: {country_name} ({country_code})"
+        self.log(info_mes)
+        show_notification(info_mes, "info")
+        
+        # 更新当前处理的国家
+        if task_id in runing_task:
+            runing_task[task_id]["current_country"] = country_name
+        
+        # 切换国家，最多重试3次
+        max_retries = 3
+        switch_success = False
+        
+        for retry in range(max_retries):
+            try:
+                self.log(f"尝试切换到国家 {country_name} (第 {retry + 1}/{max_retries} 次)")
+                
+                # 如果不是第一次尝试，先刷新页面
+                if retry > 0:
+                    self.log("重试前刷新页面...")
+                    try:
+                        driver.tab.refresh()
+                        time.sleep(3)
+                    except Exception as e:
+                        self.log(f"刷新页面失败: {str(e)}", "WARNING")
+                
+                switch_success = driver.SwitchingCountries(country_name)
+                if switch_success:
+                    self.log(f"成功切换到国家 {country_name}")
+                    break
+                else:
+                    self.log(f"切换到国家 {country_name} 失败", "WARNING")
+                    
+            except Exception as e:
+                import traceback
+                self.log(f"切换国家 {country_name} 异常: {str(e)}", "ERROR")
+                self.log(traceback.format_exc(), "ERROR")
+                
+            # 如果还有重试机会，等待后继续
+            if retry < max_retries - 1:
+                time.sleep(2)
+        
+        # 如果切换失败，直接返回
+        if not switch_success:
+            error_message = f"切换到国家 {country_name} 失败，已重试 {max_retries} 次，跳过该国家"
+            self.log(error_message, "ERROR")
+            if task_id in runing_task:
+                runing_task[task_id]["processed_countries"] += 1
+            return
+        
+        # 切换到库存管理页面
+        try:
+            driver.SwitchPage()
+            self.log(f"已切换到库存管理页面")
+        except Exception as e:
+            import traceback
+            self.log(f"切换页面失败: {str(e)}", "ERROR")
+            self.log(traceback.format_exc(), "ERROR")
+            if task_id in runing_task:
+                runing_task[task_id]["processed_countries"] += 1
+            return
+        
+        # 搜索需要审批的商品，最多重试3次
+        sku_ls = []
+        for retry in range(max_retries):
+            try:
+                self.log(f"尝试搜索匹配操作商品 (第 {retry + 1}/{max_retries} 次)")
+                sku_ls = driver.search(filter_type=risk_listing_filter)
+                break
+            except Exception as e:
+                self.log(f"搜索商品异常: {str(e)}", "ERROR")
+                if retry < max_retries - 1:
+                    try:
+                        driver.tab.refresh()
+                        time.sleep(3)
+                    except Exception as refresh_error:
+                        self.log(f"刷新页面失败: {str(refresh_error)}", "WARNING")
+        
+        # 如果没有需要审批的商品，直接返回
+        if len(sku_ls) == 0:
+            self.log(f"国家 {country_name} 没有搜索出的商品")
+            if task_id in runing_task:
+                runing_task[task_id]["processed_countries"] += 1
+            return
+        
+        self.log(f"国家 {country_name} 搜索出 {len(sku_ls)} 商品，开始处理...")
+        
+        # 处理所有需要审批的商品（通过yield获取结果）
+        try:
+            for asin, status in driver.run_page_action():
+                # 检查是否收到暂停请求
+                if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
+                    self.log(f"检测到任务 {task_id} 的暂停请求，停止处理ASIN", "WARNING")
+                    break
+                
+                self.log(f"ASIN {asin} 处理结果: {status}")
+                
+                # 更新任务状态
+                if task_id in runing_task:
+                    runing_task[task_id]["current_asin"] = asin
+                    runing_task[task_id]["processed_asins"] += 1
+                    
+                    runing_task[task_id]["failed_count"] += 1
+                
+                # 回传结果到API
+                try:
+                    self.post_result(task_id, shop_name, country_code, asin, status)
+                except Exception as e:
+                    self.log(f"回传结果失败: {str(e)}", "ERROR")
+                    
+        except Exception as e:
+            import traceback
+            self.log(f"处理审批商品异常: {str(e)}", "ERROR")
+            self.log(traceback.format_exc(), "ERROR")
+        
+        # 更新已处理国家数
+        if task_id in runing_task:
+            runing_task[task_id]["processed_countries"] += 1
+        
+        self.log(f"国家 {country_name} 处理完成")
+    
+    def post_result(self, task_id: int, shop_name: str, country_code: str, asin: str, status: str,is_done: bool = False):
+        """回传处理结果到API
+        
+        Args:
+            task_id: 任务ID
+            shop_name: 店铺名称
+            country_code: 国家代码
+            asin: ASIN
+            status: 处理状态
+        """
+        import requests
+        from config import DELETE_BRAND_API_BASE
+        
+        url = f"{DELETE_BRAND_API_BASE}/api/shop-match/tasks/{task_id}/result"
+            
+        payload = {
+            "shops": [
+                {
+                "error": "",
+                "countries": {
+                    country_code: [
+                    {
+                        "asin": asin,
+                        "status": status,
+                        "done": is_done
+                    }
+                    ]
+                },
+                "shopName": shop_name
+                }
+            ]
+        }
+        
+        max_retries = 3
+        for retry in range(max_retries):
+            try:
+                print("================【匹配】=====================")
+                self.log(f"尝试回传结果 (第 {retry + 1}/{max_retries} 次)")
+                self.log(f"回传URL: {url}")
+                self.log(f"回传数据: {payload}")
+                response = requests.post(
+                    url,
+                    json=payload,
+                    headers={"Content-Type": "application/json"},
+                    timeout=30,
+                    verify=False
+                )
+                self.log(f"回传结果: {response.text}")
+                
+                if response.status_code == 200:
+                    self.log(f"结果回传成功: {asin} - {status}")
+                    return
+                else:
+                    self.log(f"结果回传失败，状态码: {response.status_code}", "WARNING")
+                print("=====================================")
+                    
+            except Exception as e:
+                self.log(f"调用API异常: {str(e)}", "ERROR")
+                print("=====================================")
+                
+            # 如果还有重试机会，等待后继续
+            if retry < max_retries - 1:
+                time.sleep(2)
+        
+        self.log(f"已达到最大重试次数，结果回传最终失败", "ERROR")
+        
+
+
+if __name__ == "__main__":
+    user_info = {
+        "company": "rongchuang123",
+        "username": "自动化_Robot",
+        "password": "#20zsg25"
+    }
+    shop_name = "魏振峰"
+    country = "德国"
+    kill_process('v6')
+    driver = AmzoneMatchAction(user_info)
+    browser = driver.open_shop(shop_name)
+    sw_suc = driver.SwitchingCountries(country)
+    driver.SwitchPage()
+    risk_listing_filter = "All"
+    for _ in range(3):
+        try:
+            sku_ls = driver.search(filter_type=risk_listing_filter)
+            break
+        except Exception as e:
+            print(e)
+            driver.tab.refresh()
+    if len(sku_ls) > 0:
+        print("有数据，开始操作")
+        for asin, status in driver.run_page_action():
+            print(f"ASIN {asin} 的处理结果: {status}")
+        print("已完成操作")

app/amazon/tool.py

@@ -0,0 +1,77 @@
+# 导入 webview 用于前端通知
+try:
+    import webview
+except ImportError:
+    webview = None
+
+
+
+def show_notification(message: str, message_type: str = "error"):
+    """显示 pywebview 顶层通知（5秒后自动消失）
+    
+    Args:
+        message: 通知消息
+        message_type: 消息类型 (success/warning/error/info)
+    """
+    if webview and webview.windows:
+        try:
+            # 转义单引号，防止 JavaScript 语法错误
+            safe_message = message.replace("'", "\\'").replace('"', '\\"').replace('\n', '\\n')
+            
+            # 设置通知样式颜色
+            color_map = {
+                'success': '#67C23A',
+                'warning': '#E6A23C',
+                'error': '#F56C6C',
+                'info': '#909399'
+            }
+            bg_color = color_map.get(message_type, '#F56C6C')
+            
+            # 构建前端通知的 JavaScript 代码 - 创建原生 HTML 通知
+            js_code = f"""
+            (function() {{
+                // 移除已存在的通知
+                var existingNotif = document.getElementById('pywebview-notification');
+                if (existingNotif) {{
+                    existingNotif.remove();
+                }}
+                
+                // 创建通知容器
+                var notif = document.createElement('div');
+                notif.id = 'pywebview-notification';
+                notif.style.cssText = 'position: fixed; top: 20px; left: 50%; transform: translateX(-50%); ' +
+                    'background: {bg_color}; color: white; padding: 12px 20px; border-radius: 4px; ' +
+                    'box-shadow: 0 2px 12px rgba(0,0,0,0.3); z-index: 99999; font-size: 14px; ' +
+                    'max-width: 600px; word-wrap: break-word; display: flex; align-items: center; gap: 10px;';
+                
+                // 添加消息内容
+                var msgSpan = document.createElement('span');
+                msgSpan.textContent = '{safe_message}';
+                notif.appendChild(msgSpan);
+                
+                // 添加关闭按钮
+                var closeBtn = document.createElement('span');
+                closeBtn.innerHTML = '×';
+                closeBtn.style.cssText = 'cursor: pointer; font-size: 18px; font-weight: bold; margin-left: 10px;';
+                closeBtn.onclick = function() {{ notif.remove(); }};
+                notif.appendChild(closeBtn);
+                
+                // 添加到页面
+                document.body.appendChild(notif);
+                
+                // 5秒后自动消失
+                setTimeout(function() {{
+                    if (notif && notif.parentNode) {{
+                        notif.style.transition = 'opacity 0.3s';
+                        notif.style.opacity = '0';
+                        setTimeout(function() {{ notif.remove(); }}, 300);
+                    }}
+                }}, 5000);
+            }})();
+            """
+            # 在第一个窗口中执行 JavaScript
+            webview.windows[0].evaluate_js(js_code)
+        except Exception as e:
+            print(f"显示通知失败: {str(e)}")
+    
+

app/main.py

@@ -73,20 +73,26 @@ class WindowAPI:
         window.events.restored += lambda _: setattr(self, '_is_maximized', False)
 
     def close(self):
-        try:
-            self._window.destroy()
-        except:
-            pass
-        return
+        """关闭窗口，异步执行清理逻辑"""
+        def cleanup_and_exit():
+            """后台清理线程"""
             try:
                 kill_process('v6')
             except Exception as e:
                 print(f"【退出前】关闭紫鸟浏览器进程异常: {str(e)}")
+            finally:
+                time.sleep(0.5)
+                os._exit(0)
+        
+        # 先销毁窗口，让用户看到立即响应
         try:
             self._window.destroy()
         except:
             pass
-        os._exit(0)  # 强制退出整个进程，包括所有线程
+        
+        # 在后台线程执行清理，不阻塞
+        cleanup_thread = threading.Thread(target=cleanup_and_exit, daemon=True)
+        cleanup_thread.start()
 
     def minimize(self):
         self._window.minimize()
@@ -390,21 +396,24 @@ def start_task_monitor():
 
 
 def on_window_closing():
-    return
-    """窗口关闭事件处理器，执行与 close() 方法相同的清理逻辑"""
-    # 先关闭窗口，避免看起来卡着
-    try:
-        if webview.windows:
-            webview.windows[0].destroy()
-    except:
-        pass
-    
-    # 然后执行清理逻辑
+    """窗口关闭事件处理器，异步执行清理逻辑，避免阻塞UI"""
+    def cleanup_and_exit():
+        """后台清理线程"""
         try:
             kill_process('v6')
         except Exception as e:
             print(f"【退出前】关闭紫鸟浏览器进程异常: {str(e)}")
-    os._exit(0)  # 强制退出整个进程，包括所有线程
+        finally:
+            # 给一点时间让清理完成，然后强制退出
+            time.sleep(0.5)
+            os._exit(0)
+    
+    # 立即在后台线程执行清理，不阻塞窗口关闭
+    cleanup_thread = threading.Thread(target=cleanup_and_exit, daemon=True)
+    cleanup_thread.start()
+    
+    # 立即返回，让窗口快速关闭，用户不会感觉卡顿
+    return True
 
 
 def main():