ai-kf/erp_automation.py

import time
from playwright.sync_api import BrowserContext, Page

def click_safe(target, selector, wait_for=None, timeout=5000):
    try:
        target.wait_for_selector(selector, state="visible", timeout=timeout)
        target.click(selector, force=True)
        time.sleep(1)
        if wait_for:
            target.wait_for_selector(wait_for, state="visible", timeout=timeout)
        return True
    except:
        return False

def close_guides(page_or_frame):
    """
    清理各种引导泡泡和弹窗 (增强版)
    """
    try:
        # 常见引导按钮文本和选择器
        guide_selectors = [
            "text=不再提示", "text=点击关闭", "text=我知道了", "text=下次再说",
            ".auxo-modal-close", ".arco-icon-close", ".auxo-guide-close",
            ".auxo-btn:has-text('不再提示')", ".arco-btn:has-text('不再提示')",
            "div[class*='guide'] .btn:has-text('关闭')"
        ]
        
        # 处理可能的多个引导
        for sel in guide_selectors:
            try:
                locators = page_or_frame.locator(sel)
                count = locators.count()
                for i in range(count):
                    loc = locators.nth(i)
                    if loc.is_visible():
                        print(f"    [清理引导] 正在关闭: {sel}")
                        loc.click(force=True, timeout=1000)
                        time.sleep(0.5)
            except:
                continue
    except:
        pass

def find_work_context(page):
    """
    不仅在主页，还要探测关键业务 Iframe (专业版适配)
    """
    # 特征点
    features = ["text=组合查询", "span.btn_search", ".btn-search", "text=等待订单合并"]
    
    # 1. 探测 Iframe (聚水潭业务通常嵌套在名为 epaas-iframe 或特定 ID 的 frame 中)
    for frame in page.frames:
        try:
            # 检查是否有业务特征
            for feat in features:
                if frame.locator(feat).count() > 0:
                    print(f"    [探测] 成功锁定业务 Frame: {frame.name or frame.url[:40]}...")
                    return frame
        except:
            continue

    # 2. 检查主页面
    for feat in features:
        if page.locator(feat).count() > 0:
            return page
            
    return None

def run_sync(browser_context: BrowserContext):
    print("\n[ERP自动化] 启动执行任务...")
    
    # 1. 查找或开启页面
    page = None
    for p in browser_context.pages:
        if "erp321.com" in p.url:
            page = p
            print("  -> 复用已有聚水潭页面...")
            break
    if not page:
        print("  -> 开启新标签页...")
        page = browser_context.new_page()
    
    should_close = True
    try:
        if "erp321.com" not in page.url or "login" in page.url:
            print("  -> 正在打开页面...")
            page.goto("https://www.erp321.com/epaas", timeout=60000)
        
        # 2. 清理首页可能的引导
        close_guides(page)

        # 3. 识别状态 (增强：如果已经在订单页 Iframe 里也能识别)
        print("  -> 正在识别页面状态...")
        work_canvas = find_work_context(page)
        
        if work_canvas:
            print("  ✅ 检测到已处于订单管理界面，跳过首页点击。")
        else:
            # 入口尝试路径：针对专业版进行优化
            entrance_selectors = [
                "a.menuItem___5lTDZ:has(p:text('订单'))",
                "p:text-is('订单')",
                "div[class*='menuItem']:has-text('订单')",
                "li:has-text('订单')",
                "text=订单"
            ]
            
            clicked = False
            # 在尝试点击前，先清理一次主页面的遮挡
            close_guides(page)
            
            for sel in entrance_selectors:
                try:
                    loc = page.locator(sel).first
                    if loc.count() > 0 and loc.is_visible():
                        print(f"    -> 步骤1: 触发测边栏入口: {sel}")
                        loc.click(force=True, timeout=3000)
                        time.sleep(1)
                        
                        # 步骤2: 聚水潭专业版通常需要二次点击浮层中的“订单”文字
                        time.sleep(1.5)
                        # 优先匹配面板内的文字
                        secondary_selectors = [
                            "div:text-is('订单')",
                            "span:text-is('订单')",
                            "a:has-text('订单')"
                        ]
                        for sec_sel in secondary_selectors:
                            try:
                                sec_loc = page.locator(sec_sel).filter(has_not=page.locator(sel)).first
                                if sec_loc.count() > 0 and sec_loc.is_visible():
                                    print(f"    -> 步骤2: 点击展开面板中的实体文字: {sec_sel}")
                                    sec_loc.click(force=True, timeout=2000)
                                    time.sleep(1)
                                    clicked = True
                                    break
                            except:
                                continue
                        
                        if clicked: break
                        # 如果没有找到二级，可能一步就到位了
                        clicked = True
                        break
                except:
                    continue
            
            if not clicked:
                # 最后的兜底：尝试点击侧边栏图标区域
                try:
                    print("    -> 尝试兜底坐标点击侧边栏区域...")
                    page.mouse.click(30, 100) # 通常侧边栏订单按钮在左上角区域
                    clicked = True
                except:
                    pass
            
            if not clicked:
                print("  ❌ 无法识别“订单”入口，请确保已登录并处于正常界面。")
                should_close = False
                return False
            
            print("  -> 已触发点击，等待工作台加载...")
            for i in range(5):
                time.sleep(3)
                work_canvas = find_work_context(page)
                if work_canvas: break
                print(f"    (正在探测管理界面... 第 {i+1}/5 次)")
        
        if not work_canvas:
            print("  ⚠️ 未探测到工作环境，任务挂起。")
            should_close = False
            return False
        
        print(f"  ✅ 已锁定工作台: {getattr(work_canvas, 'name', '订单子系统')}")
        
        # 进入工作台后的第一件事：清理工作台内的所有新手引导！
        close_guides(work_canvas)

        # 4. 执行业务逻辑 (必须在 work_canvas 中)
        # 清理工作台内的顶部干扰（如归档提醒等）
        try:
            ignore_bar = work_canvas.locator("#ArchiveOrderCloseBtn, .close-btn-tips").first
            if ignore_bar.count() > 0 and ignore_bar.is_visible():
                ignore_bar.click(force=True, timeout=2000)
                time.sleep(1)
        except: pass

        print("  -> 勾选'等待订单合并'...")
        is_checked = False
        try:
            # === 跨所有 frame 搜索 input#q_11 ===
            # work_canvas 可能不包含筛选面板，需要遍历所有 frame 找到真正包含 #q_11 的那个
            target_frame = None
            
            # 1. 先在 work_canvas 中找
            if work_canvas.locator("input#q_11").count() > 0:
                target_frame = work_canvas
                print("    -> 在 work_canvas 中找到 #q_11。")
            else:
                # 2. 遍历所有 frame
                print("    -> work_canvas 中未找到 #q_11，遍历所有 frame...")
                for frame in page.frames:
                    try:
                        fname = frame.name or frame.url[:60]
                        count = frame.locator("input#q_11").count()
                        if count > 0:
                            target_frame = frame
                            print(f"    -> 在 frame [{fname}] 中找到 #q_11！")
                            break
                        # 也试试 #f_panel
                        if frame.locator("#f_panel").count() > 0:
                            target_frame = frame
                            print(f"    -> 在 frame [{fname}] 中找到 #f_panel！")
                            break
                    except Exception as fe:
                        continue
            
            if target_frame is None:
                # 3. 诊断输出：列出所有 frame 和它们能看到的元素
                print("    ⚠️ 所有 frame 中均未找到 #q_11，诊断信息：")
                for idx, frame in enumerate(page.frames):
                    try:
                        fname = frame.name or "unnamed"
                        furl = frame.url[:80] if frame.url else "no-url"
                        has_panel = frame.locator("#f_panel").count()
                        has_status = frame.locator("#p_status").count()
                        has_other_qs = frame.locator("#other_qs").count()
                        has_label = frame.locator("label:has-text('等待订单合并')").count()
                        print(f"      frame[{idx}] name={fname} url={furl}")
                        print(f"        #f_panel={has_panel} #p_status={has_status} #other_qs={has_other_qs} label(等待订单合并)={has_label}")
                    except:
                        print(f"      frame[{idx}] - 访问失败")
                print("    ⚠️ 所有方法均未找到'等待订单合并'复选框。")
            else:
                # 确保异常子分类区域展开
                try:
                    other_qs = target_frame.locator("#other_qs")
                    if other_qs.count() > 0 and not other_qs.is_visible():
                        arrow = target_frame.locator("#oql_")
                        if arrow.count() > 0:
                            arrow.click(force=True)
                            time.sleep(0.5)
                            print("    -> 已展开'异常'子分类区域。")
                except:
                    pass

                # 勾选 checkbox
                cb = target_frame.locator("input#q_11")
                if cb.count() > 0:
                    try:
                        cb.scroll_into_view_if_needed(timeout=3000)
                    except:
                        pass
                    time.sleep(0.3)
                    if not cb.is_checked():
                        cb.check(force=True, timeout=5000)
                    is_checked = True
                    print("    ✅ 成功勾选'等待订单合并'。")
                else:
                    # 用 label 点击
                    label = target_frame.locator("label[for='q_11']")
                    if label.count() > 0:
                        label.click(force=True, timeout=5000)
                        time.sleep(1)
                        is_checked = True
                        print("    ✅ 通过 label 点击勾选'等待订单合并'。")
                
                # 如果 target_frame 和 work_canvas 不同，更新 work_canvas 供后续使用
                if target_frame is not work_canvas:
                    print("    -> 更新 work_canvas 为包含筛选面板的 frame。")
                    work_canvas = target_frame

            time.sleep(1.5)
        except Exception as e:
            print(f"    ⚠️ 勾选逻辑执行异常: {e}")


        # 熔断判断
        if not is_checked:
            print("  ❌ [安全熔断] 无法确认‘等待订单合并’勾选状态，任务已终止。")
            should_close = False
            return False

        print("  -> 执行'组合查询'...")
        try:
            # 使用 locator 代替 evaluate（跨域兼容）
            search_btn = work_canvas.locator(".btn-search, span.btn_search").first
            if search_btn.count() > 0:
                search_btn.click(force=True, timeout=5000)
                time.sleep(1)
            else:
                search_text = work_canvas.locator("span:has-text('组合查询'), button:has-text('组合查询')").first
                if search_text.count() > 0:
                    search_text.click(force=True, timeout=5000)
                    time.sleep(1)
                else:
                    print("    ⚠️ 未找到'组合查询'按钮。")
            time.sleep(2)
        except Exception as e:
            print(f"    ⚠️ 组合查询点击异常: {e}")

        print("  -> 勾选全选...")
        try:
            # 跨 frame 搜索全选框 (可能在不同于筛选面板的 frame 中)
            select_frame = None
            select_cb = None
            
            # 先在 work_canvas 中找
            cb = work_canvas.locator("#_jt_h_checked")
            if cb.count() > 0:
                select_frame = work_canvas
                select_cb = cb
            else:
                # 遍历所有 frame
                for frame in page.frames:
                    try:
                        cb = frame.locator("#_jt_h_checked")
                        if cb.count() > 0:
                            select_frame = frame
                            select_cb = cb
                            fname = frame.name or frame.url[:60]
                            print(f"    -> 在 frame [{fname}] 中找到全选框。")
                            break
                    except:
                        continue
            
            if select_cb is not None:
                if not select_cb.is_checked():
                    select_cb.click(force=True, timeout=5000)
                    time.sleep(1)
                print("    ✅ 成功勾选全选。")
            else:
                print("    ⚠️ 未发现全选框。")
        except Exception as e:
            print(f"    ⚠️ 全选框操作异常: {e}")

        print("  -> 触发'智能合并'...")
        try:
            # 跨 frame 搜索懒人自动化/智能合并入口
            action_frame = select_frame or work_canvas
            
            # 先在 action_frame 中找
            menu_loc = action_frame.locator("#ZZ").first
            if menu_loc.count() == 0:
                # 在所有 frame 中找 #ZZ
                for frame in page.frames:
                    try:
                        loc = frame.locator("#ZZ")
                        if loc.count() > 0:
                            action_frame = frame
                            menu_loc = loc.first
                            fname = frame.name or frame.url[:60]
                            print(f"    -> 在 frame [{fname}] 中找到 #ZZ。")
                            break
                    except:
                        continue
            
            if menu_loc.count() == 0:
                # 尝试文本匹配
                for frame in page.frames:
                    try:
                        loc = frame.locator("div:has-text('懒人自动化'), span:has-text('懒人自动化')").first
                        if loc.count() > 0:
                            action_frame = frame
                            menu_loc = loc
                            break
                    except:
                        continue
            
            if menu_loc.count() > 0:
                try:
                    menu_loc.scroll_into_view_if_needed(timeout=3000)
                except:
                    pass
                menu_loc.click(force=True)
                time.sleep(2)  # 等待下拉菜单完全展开
                
                # 点击智能合并 - 等待元素变为可见再点击
                merge_clicked = False
                merge_selectors = [
                    ".title_div:has-text('智能合并')",
                    "div:text-is('智能合并')",
                    "span:text-is('智能合并')",
                    "a:text-is('智能合并')",
                    "div:not(.content_div):has-text('智能合并')",
                ]
                
                # 在 action_frame 和所有 frame 中查找可见的智能合并
                frames_to_try = [action_frame] + [f for f in page.frames if f is not action_frame]
                for fr in frames_to_try:
                    if merge_clicked:
                        break
                    for sel in merge_selectors:
                        try:
                            loc = fr.locator(sel).first
                            if loc.count() > 0:
                                # 等待元素可见（最多3秒）
                                try:
                                    loc.wait_for(state="visible", timeout=3000)
                                except:
                                    pass
                                if loc.is_visible():
                                    print(f"    -> 执行二级点击：智能合并 (selector={sel})")
                                    loc.click(force=True)
                                    time.sleep(1)
                                    merge_clicked = True
                                    break
                        except:
                            continue
                
                if not merge_clicked:
                    print("    ⚠️ 未找到可见的'智能合并'按钮。")
            else:
                print("    ⚠️ 未发现'懒人自动化'入口（已搜索所有 frame）。")
        except Exception as e:
            print(f"    ⚠️ 智能合并流程故障: {e}")

        # 确认弹窗处理
        print("  -> 等待确认弹窗...")
        time.sleep(3)
        
        confirmed = False
        # 确认按钮是 <input type="button" id="confirm_confirm" value="确认">
        confirm_selectors = [
            "input#confirm_confirm",
            "input[value='确认']",
            "input[type='button'][value='确认']",
            "#confirm_btn_div input.btn_1",
        ]
        
        # 搜索所有 frame
        for frame in page.frames:
            if confirmed:
                break
            try:
                for c_sel in confirm_selectors:
                    try:
                        btn = frame.locator(c_sel).first
                        if btn.count() > 0:
                            btn.click(force=True, timeout=3000)
                            time.sleep(1)
                            fname = frame.name or "main"
                            print(f"  ✅ 成功点击确认按钮 (frame={fname})。")
                            confirmed = True
                            break
                    except:
                        continue
            except:
                continue
        
        # 如果没找到，等 3 秒重试
        if not confirmed:
            time.sleep(3)
            for frame in page.frames:
                if confirmed:
                    break
                try:
                    btn = frame.locator("input#confirm_confirm").first
                    if btn.count() > 0:
                        btn.click(force=True, timeout=3000)
                        time.sleep(1)
                        print(f"  ✅ 成功点击确认按钮 (第二轮)。")
                        confirmed = True
                except:
                    continue
        
        if not confirmed:
            print("  ⚠️ 未能自动点击确认弹窗。")
        
        time.sleep(2)


        # ========== 智能合并后续流程 ==========
        
        # --- 辅助函数：跨 frame 关闭提示弹窗 (a#msg_close) ---
        def close_msg_dialog(description="提示弹窗"):
            time.sleep(2)
            for frame in page.frames:
                try:
                    close_btn = frame.locator("a#msg_close").first
                    if close_btn.count() > 0:
                        close_btn.click(force=True, timeout=3000)
                        time.sleep(1)
                        print(f"    ✅ 已关闭{description}。")
                        return True
                except:
                    continue
            print(f"    ℹ️ 未发现{description}。")
            return False
        
        # --- 辅助函数：跨 frame 点击组合查询 ---
        def click_search():
            for frame in page.frames:
                try:
                    btn = frame.locator(".btn-search, span.btn_search").first
                    if btn.count() > 0:
                        btn.click(force=True, timeout=5000)
                        time.sleep(1)
                        print("    ✅ 已点击组合查询。")
                        return True
                    txt = frame.locator("span:has-text('组合查询'), button:has-text('组合查询')").first
                    if txt.count() > 0:
                        txt.click(force=True, timeout=5000)
                        time.sleep(1)
                        print("    ✅ 已点击组合查询。")
                        return True
                except:
                    continue
            return False
        
        # --- 辅助函数：跨 frame 全选 ---
        def click_select_all():
            for frame in page.frames:
                try:
                    cb = frame.locator("#_jt_h_checked").first
                    if cb.count() > 0:
                        if not cb.is_checked():
                            cb.click(force=True, timeout=5000)
                            time.sleep(1)
                        print("    ✅ 已全选。")
                        return True
                except:
                    continue
            return False
        
        # --- 辅助函数：跨 frame 查找筛选面板 frame ---
        def find_filter_frame():
            for frame in page.frames:
                try:
                    if frame.locator("#f_panel").count() > 0 or frame.locator("input#q_11").count() > 0:
                        return frame
                except:
                    continue
            return None
        
        # --- 辅助函数：检查是否有订单数据行 ---
        def has_data_rows():
            for frame in page.frames:
                try:
                    rows = frame.locator("._jt_row, tr[data-id]").count()
                    if rows > 0:
                        print(f"    -> 发现 {rows} 条订单数据。")
                        return True, rows
                except:
                    continue
            return False, 0

        if confirmed:
            # 步骤A: 关闭智能合并成功弹窗
            print("  -> 关闭智能合并成功弹窗...")
            close_msg_dialog("智能合并成功弹窗")
            time.sleep(1)
            
            # 步骤B: 重新组合查询，检查是否有剩余未合并订单
            print("  -> 重新组合查询检查剩余订单...")
            click_search()
            time.sleep(3)
            
            has_remaining, remaining_count = has_data_rows()
            
            if has_remaining:
                print(f"  -> 还有 {remaining_count} 条剩余订单，执行'转到待审核'...")
                
                # 全选剩余订单
                click_select_all()
                time.sleep(1)
                
                # 点击"转到待审核"按钮
                transfer_clicked = False
                transfer_selectors = [
                    "span#ToWaitConfirm",
                    "#ToWaitConfirm",
                ]
                for frame in page.frames:
                    if transfer_clicked:
                        break
                    try:
                        for sel in transfer_selectors:
                            loc = frame.locator(sel).first
                            if loc.count() > 0 and loc.is_visible():
                                loc.click(force=True, timeout=5000)
                                time.sleep(1)
                                print(f"    ✅ 已点击'转到待审核' (sel={sel})。")
                                transfer_clicked = True
                                break
                    except:
                        continue
                
                if transfer_clicked:
                    # 等待并关闭转到待审核的结果弹窗
                    print("  -> 等待'转到待审核'结果弹窗...")
                    time.sleep(3)
                    close_msg_dialog("转到待审核结果弹窗")
                else:
                    print("    ⚠️ 未找到'转到待审核'按钮。")
            else:
                print("  -> 没有剩余订单，跳过转审核步骤。")
            
            # ========== 步骤C-E: 全流程处理（执行两遍以防遗漏） ==========
            for process_round in range(2):
                print(f'\n  ========== 开始第 {process_round+1} 轮“已付款待审核”全流程处理 ==========')
                # 步骤C: 切换筛选条件 - 取消"等待订单合并"，勾选"已付款待审核"
                print("  -> 切换筛选条件：取消'等待订单合并'，勾选'已付款待审核'...")
                filter_frame = find_filter_frame()
                if filter_frame:
                    try:
                        # 取消勾选"等待订单合并" (q_11)
                        q11 = filter_frame.locator("input#q_11")
                        if q11.count() > 0 and q11.is_checked():
                            q11.click(force=True)
                            time.sleep(1)
                            print("    ✅ 已取消勾选'等待订单合并'。")
                    
                        # 取消勾选"异常" (status_question)
                        question_cb = filter_frame.locator("input#status_question")
                        if question_cb.count() > 0 and question_cb.is_checked():
                            question_cb.click(force=True)
                            time.sleep(1)
                            print("    ✅ 已取消勾选'异常'状态。")
                        else:
                            # 尝试通过 label 判断和点击（兜底）
                            q_label = filter_frame.locator("label[for='status_question']")
                            if q_label.count() > 0:
                                # 某些情况下，无法直接读取 checkbox 的 check 状态，可以通过重新勾选来确保
                                # 但既然我们能查 input#status_question，优先依赖前面的逻辑
                                pass
                    
                        # 勾选"已付款待审核" - 需要找到对应的 checkbox ID
                        # 常见的状态选择器格式: input#q_XX
                        # 先尝试通过 label 文本查找
                        # 勾选"已付款待审核" (input#status_waitconfirm)
                        paid_checked = False
                        paid_cb = filter_frame.locator("input#status_waitconfirm")
                        if paid_cb.count() > 0:
                            if not paid_cb.is_checked():
                                paid_cb.click(force=True)
                                time.sleep(1)
                            paid_checked = True
                            print("    ✅ 已勾选'已付款待审核'。")
                        else:
                            # 兜底：通过 label 点击
                            paid_label = filter_frame.locator("label[for='status_waitconfirm']")
                            if paid_label.count() > 0:
                                paid_label.first.click(force=True)
                                time.sleep(1)
                                paid_checked = True
                                print("    ✅ 已勾选'已付款待审核' (通过 label)。")
                            else:
                                print("    ⚠️ 未找到'已付款待审核'选项。")
    
                        if not paid_checked:
                            # 方法2: 通过 #p_status 状态面板中查找
                            status_inputs = filter_frame.locator("#p_status input[type='checkbox']")
                            count = status_inputs.count()
                            for idx in range(count):
                                inp = status_inputs.nth(idx)
                                try:
                                    title = inp.get_attribute("title") or ""
                                    if "已付款待审核" in title:
                                        if not inp.is_checked():
                                            inp.click(force=True)
                                            time.sleep(1)
                                        paid_checked = True
                                        print(f"    ✅ 已勾选'已付款待审核' (input title)。")
                                        break
                                except:
                                    continue
                    
                        if not paid_checked:
                            print("    ⚠️ 未找到'已付款待审核'选项。")
                    
                        time.sleep(1)
                    except Exception as e:
                        print(f"    ⚠️ 切换筛选条件异常: {e}")
                else:
                    print("    ⚠️ 未找到筛选面板 frame。")
            
                # 步骤D: 最后一次组合查询
                print("  -> 最终组合查询...")
                click_search()
                time.sleep(2)
                print("  ✅ 智能合并+转审核流程完成，继续处理已付款待审核订单。")
    
                # ========== 步骤E: 已付款待审核订单处理 ==========
                print("  -> 步骤E: 处理已付款待审核订单...")
                time.sleep(3)
            
                # E1: 全选
                print("  -> 全选已付款待审核订单...")
                click_select_all()
                time.sleep(1)
            
                # E2: 取消勾选含"预售"标记或"补色专用"商品名的订单
                print("  -> 取消勾选含'预售'标记或'补色专用'商品的订单...")
                uncheck_count = 0
                # 在包含表格的 frame 中操作（iframe-132）
                table_frame = None
                for frame in page.frames:
                    try:
                        if frame.locator("#_jt_h_checked").count() > 0:
                            table_frame = frame
                            break
                    except:
                        continue
            
                if table_frame:
                    try:
                        # 等待行数据渲染（组合查询后可能需要时间）
                        try:
                            table_frame.locator("._jt_row").first.wait_for(state="attached", timeout=5000)
                        except:
                            pass
                        processed_indices = set()
                    
                        print("    -> 开始滚动检查并取消勾选...")
                        for scroll_round in range(20):
                            rows = table_frame.locator("._jt_row")
                            row_count = rows.count()
                        
                            new_rows_in_view = 0
                            for idx in range(row_count):
                                try:
                                    row = rows.nth(idx)
                                    row_idx = row.get_attribute("index")
                                    if not row_idx:
                                        row_idx = f"unknown_{idx}_{scroll_round}"
                                
                                    if row_idx in processed_indices:
                                        continue
                                
                                    processed_indices.add(row_idx)
                                    new_rows_in_view += 1
                                
                                    row_text = row.inner_text(timeout=2000)
                                    try:
                                        row_html = row.inner_html(timeout=2000)
                                    except:
                                        row_html = ""
                                
                                    should_uncheck = False
                                    reason = ""
                                    if "预售" in row_text or "预售" in row_html:
                                        should_uncheck = True
                                        reason = "预售"
                                    elif "补色" in row_text or "补色" in row_html:
                                        should_uncheck = True
                                        reason = "补色"
                                
                                    if should_uncheck:
                                        cb = row.locator("input[type='checkbox']._jt_cbx").first
                                        if cb.count() > 0 and cb.is_checked():
                                            cb.click(force=True)
                                            time.sleep(0.5)
                                            uncheck_count += 1
                                            print(f"    ✅ 已取消勾选第{row_idx}行 (含'{reason}')。")
                                except Exception as e:
                                    continue
                        
                            if new_rows_in_view == 0 and scroll_round > 0:
                                # 给最后一次机会，再等0.5秒检查一下
                                time.sleep(0.5)
                                rows_after_wait = table_frame.locator("._jt_row").count()
                                if rows_after_wait == 0 or rows_after_wait <= len(processed_indices):
                                    break
                        
                            if len(processed_indices) >= 50:
                                print("    -> 已检查满 50 行，停止滚动检查。")
                                break
                            
                            # 往下滚动
                            try:
                                scroll_target = table_frame.locator("#_jt_body")
                                if scroll_target.count() > 0:
                                    # 每次向下滚动 400 像素，避免滚得太快跳过中间的数据
                                    scroll_target.first.evaluate("el => el.scrollTop += 400")
                                    time.sleep(1.5) # 给一点时间让虚拟列表渲染 DOM
                                else:
                                    break
                            except:
                                break
                    
                        print(f"    -> 取消勾选完成，共检查 {len(processed_indices)} 行数据，取消了 {uncheck_count} 行。")
                    except Exception as e:
                        print(f"    ⚠️ 取消勾选异常: {e}")
                else:
                    print("    ⚠️ 未找到表格 frame。")
            
    
                # E3: 点击"修改发货仓库"按钮
                print("  -> 点击'修改发货仓库'...")
                wh_clicked = False
                wh_selectors = [
                    "span.ding_db_txt:has-text('修改发货仓库')",
                    "span[style*='confirm.png']:has-text('修改发货仓库')",
                    "span:text-is('修改发货仓库')",
                    "#ChangeWms",
                    "span._jt_tool:has-text('修改发货仓库')",
                    "span[onclick*='ChangeWms']",
                    "span:has-text('修改发货仓库')",
                ]
                for frame in page.frames:
                    if wh_clicked:
                        break
                    try:
                        for sel in wh_selectors:
                            loc = frame.locator(sel).first
                            if loc.count() > 0 and loc.is_visible():
                                loc.click(force=True, timeout=5000)
                                time.sleep(1)
                                print(f"    ✅ 已点击'修改发货仓库'。")
                                wh_clicked = True
                                break
                    except:
                        continue
            
                if not wh_clicked:
                    print("    ⚠️ 未找到'修改发货仓库'按钮。")
            
                time.sleep(2)
            
                # E4: 在弹窗中选择"依照订单分配策略自动计算" (input#p_2)
                if wh_clicked:
                    print("  -> 选择'依照订单分配策略自动计算'...")
                    strategy_selected = False
                    for frame in page.frames:
                        if strategy_selected:
                            break
                        try:
                            radio = frame.locator("input#p_2")
                            if radio.count() > 0:
                                radio.click(force=True, timeout=3000)
                                time.sleep(1)
                                print("    ✅ 已选择'依照订单分配策略自动计算'。")
                                strategy_selected = True
                        except:
                            continue
                
                    if not strategy_selected:
                        # 兜底: 通过 label 点击
                        for frame in page.frames:
                            try:
                                lbl = frame.locator("label[for='p_2']")
                                if lbl.count() > 0:
                                    lbl.click(force=True, timeout=3000)
                                    time.sleep(1)
                                    print("    ✅ 已选择'依照订单分配策略自动计算' (通过 label)。")
                                    strategy_selected = True
                                    break
                            except:
                                continue
                
                    if not strategy_selected:
                        print("    ⚠️ 未找到'依照订单分配策略自动计算'选项。")
                
                    time.sleep(1)
                
                    # E5: 点击确认按钮（可能有2次确认弹窗）
                    for confirm_round in range(2):
                        print(f"  -> 点击确认 (第{confirm_round+1}次)...")
                        time.sleep(2)
                    
                        click_confirmed = False
                        for frame in page.frames:
                            if click_confirmed:
                                break
                            try:
                                # 支持多种确认按钮：input#confirm_confirm, span#confirmBtn 等
                                btn = frame.locator("input#confirm_confirm, span#confirmBtn, span.btn_1:has-text('确认'), span.btn_1:has-text('确定'), .layui-layer-btn0, .layui-layer-btn1, a:text-is('确定'), button:text-is('确定'), a:text-is('是'), button:text-is('是'), a.btn_1:text-is('是'), span.btn_1:text-is('是'), .layui-layer-btn a:text-is('是'), input[type='button'][value='是'], input.btn_1[value='是']").first
                                if btn.count() > 0:
                                    btn.click(force=True, timeout=3000)
                                    time.sleep(1)
                                    print(f"    ✅ 已点击确认按钮 (第{confirm_round+1}次)。")
                                    click_confirmed = True
                            except:
                                continue
                    
                        if not click_confirmed:
                            print(f"    ℹ️ 第{confirm_round+1}次确认弹窗未出现。")
                            break
                    
                        time.sleep(2)
                
                    # E6: 关闭可能的成功提示弹窗
                    print("  -> 关闭操作结果弹窗...")
                    close_msg_dialog("修改发货仓库结果弹窗")
                    time.sleep(1)
                
                    print("  ✅ 已付款待审核订单处理完成。")
    
                # E7: 点击转正常单
                print("  -> 点击'转正常单'...")
                unquestion_clicked = False
                for frame in page.frames:
                    try:
                        btn = frame.locator("span#UnQuestions:has-text('转正常单'), span._jt_tool:has-text('转正常单')").first
                        if btn.count() > 0 and btn.is_visible():
                            btn.click(force=True, timeout=3000)
                            time.sleep(1)
                            print("    ✅ 已点击'转正常单'。")
                            unquestion_clicked = True
                            break
                    except:
                        continue
            
                if not unquestion_clicked:
                    print("    ⚠️ 未找到'转正常单'按钮。")
                
                time.sleep(2)
                # 处理转正常单可能的提示弹窗（比如只有异常单才可以转正常单的提示）
                close_msg_dialog("转正常单结果提示")
                time.sleep(1)
            
                # E8: 设快递
                print("  -> 点击'设快递'...")
                kuaidi_clicked = False
                for frame in page.frames:
                    try:
                        btn = frame.locator("span._db_txt:text-is('设快递'), span:text-is('设快递')").first
                        if btn.count() > 0 and btn.is_visible():
                            btn.click(force=True, timeout=3000)
                            time.sleep(1)
                            print("    ✅ 已点击'设快递'。")
                            kuaidi_clicked = True
                            break
                    except:
                        continue
            
                if not kuaidi_clicked:
                    print("    ⚠️ 未找到'设快递'按钮。")
            
                time.sleep(2)
                if kuaidi_clicked:
                    print("  -> 选择'让系统自动计算'...")
                    sys_selected = False
                    for frame in page.frames:
                        try:
                            radio = frame.locator("input#SYS[name='lc']").first
                            if radio.count() > 0:
                                radio.click(force=True, timeout=3000)
                                time.sleep(1)
                                print("    ✅ 已选择'让系统自动计算'。")
                                sys_selected = True
                                break
                        except:
                            continue
                
                    if not sys_selected:
                        # 兜底通过 label 点击
                        for frame in page.frames:
                            try:
                                lbl = frame.locator("label[for='SYS']").first
                                if lbl.count() > 0:
                                    lbl.click(force=True, timeout=3000)
                                    time.sleep(1)
                                    print("    ✅ 已选择'让系统自动计算' (通过 label)。")
                                    sys_selected = True
                                    break
                            except:
                                continue
                
                    if not sys_selected:
                        print("    ⚠️ 未找到'让系统自动计算'选项。")
                    
                    time.sleep(1)
                
                    # 点击设快递的确认按钮（可能有2次）
                    for confirm_round in range(2):
                        print(f"  -> 点击确认设快递 (第{confirm_round+1}次)...")
                        time.sleep(2)
                    
                        click_confirmed = False
                        for frame in page.frames:
                            if click_confirmed:
                                break
                            try:
                                # 优先找 input#confirm_confirm, span#confirmBtn, span.btn_1:has-text('确定')
                                btn = frame.locator("input#confirm_confirm, span#confirmBtn, span.btn_1:has-text('确定'), span:text-is('确定'), .layui-layer-btn0, a:text-is('确定'), button:text-is('确定')").first
                                if btn.count() > 0:
                                    btn.click(force=True, timeout=3000)
                                    time.sleep(1)
                                    print(f"    ✅ 已点击确认按钮 (第{confirm_round+1}次)。")
                                    click_confirmed = True
                            except:
                                continue
                    
                        if not click_confirmed:
                            print(f"    ℹ️ 第{confirm_round+1}次确认弹窗未出现。")
                            break
                        time.sleep(2)
                    
                # 处理设快递可能出现的成功提示弹窗
                close_msg_dialog("设快递结果提示")
                time.sleep(1)
            
                # E9: 审核
                print("  -> 点击'审核'...")
                audit_clicked = False
                for frame in page.frames:
                    try:
                        # 必须是可见的按钮，并且包含特定的背景图片特征
                        btn_loc = frame.locator("span.ding_db_txt[style*='Confirm.png']:has-text('审核') >> visible=true")
                        if btn_loc.count() > 0:
                            btn = btn_loc.first
                            btn.evaluate("el => el.click()")
                            time.sleep(1)
                            print("    ✅ 已点击'审核' (JS触发)。")
                            audit_clicked = True
                            break
                    except:
                        continue
            
                if not audit_clicked:
                    print("    ⚠️ 未找到'审核'按钮。")
                
                time.sleep(2)
                # 处理审核结果弹窗
                close_msg_dialog("审核结果提示")

                # E10: 转异常流程
                print("  -> 开始'转异常'流程...")
                print("  -> 再次执行组合查询...")
                click_search()
                time.sleep(3)
                
                print("  -> 滚动检查并只勾选'预售'的订单...")
                table_frame = None
                for frame in page.frames:
                    try:
                        if frame.locator("#_jt_h_checked").count() > 0:
                            table_frame = frame
                            break
                    except:
                        continue
                
                check_count = 0
                if table_frame:
                    try:
                        select_all_cb = table_frame.locator("#_jt_h_checked")
                        if select_all_cb.count() > 0 and select_all_cb.is_checked():
                            select_all_cb.click(force=True)
                            time.sleep(1)
                            
                        try:
                            table_frame.locator("._jt_row").first.wait_for(state="attached", timeout=5000)
                        except:
                            pass
                            
                        processed_indices = set()
                        for scroll_round in range(20):
                            rows = table_frame.locator("._jt_row")
                            row_count = rows.count()
                            new_rows_in_view = 0
                            
                            for idx in range(row_count):
                                try:
                                    row = rows.nth(idx)
                                    row_idx = row.get_attribute("index")
                                    if not row_idx:
                                        row_idx = f"unknown_{idx}_{scroll_round}"
                                        
                                    if row_idx in processed_indices:
                                        continue
                                        
                                    processed_indices.add(row_idx)
                                    new_rows_in_view += 1
                                    
                                    row_text = row.inner_text(timeout=2000)
                                    try:
                                        row_html = row.inner_html(timeout=2000)
                                    except:
                                        row_html = ""
                                        
                                    should_check = False
                                    reason = ""
                                    if "补色" in row_text or "补色" in row_html:
                                        should_check = False
                                    elif "预售" in row_text or "预售" in row_html:
                                        should_check = True
                                        reason = "预售"
                                        
                                    if should_check:
                                        cb = row.locator("input[type='checkbox']._jt_cbx").first
                                        if cb.count() > 0 and not cb.is_checked():
                                            cb.click(force=True)
                                            time.sleep(0.5)
                                            check_count += 1
                                            print(f"    ✅ 已勾选第{row_idx}行 (含'{reason}')。")
                                except:
                                    continue
                                    
                            if new_rows_in_view == 0 and scroll_round > 0:
                                break
                            if len(processed_indices) >= 50:
                                print("    -> 已检查满 50 行，停止滚动检查。")
                                break
                                
                            try:
                                scroll_target = table_frame.locator("#_jt_body")
                                if scroll_target.count() > 0:
                                    scroll_target.first.evaluate("el => el.scrollTop += 400")
                                    time.sleep(1.5)
                                else:
                                    break
                            except:
                                break
                    except Exception as e:
                        print(f"    ⚠️ 勾选异常订单失败: {e}")
                
                if check_count > 0:
                    print("  -> 点击'转异常'...")
                    question_clicked = False
                    for frame in page.frames:
                        try:
                            btn = frame.locator("span#Questions:has-text('转异常'), span._jt_tool:has-text('转异常')").first
                            if btn.count() > 0 and btn.is_visible():
                                btn.click(force=True, timeout=3000)
                                time.sleep(1)
                                print("    ✅ 已点击'转异常'。")
                                question_clicked = True
                                break
                        except:
                            continue
                    
                    time.sleep(2)
                    
                    if question_clicked:
                        print("  -> 选择'特殊单'...")
                        special_selected = False
                        for frame in page.frames:
                            try:
                                lbl = frame.locator("label:text-is('特殊单')").first
                                if lbl.count() > 0:
                                    # 1. 强制点击 label
                                    lbl.click(force=True, timeout=3000)
                                    
                                    # 2. 用 JS 点击父元素 div
                                    lbl.evaluate("el => { if(el.parentElement) el.parentElement.click(); }")
                                    
                                    # 3. 强制修改底层 input 状态并派发事件
                                    radio = frame.locator("input[value='特殊单']").first
                                    if radio.count() > 0:
                                        radio.evaluate("el => { el.checked = true; el.dispatchEvent(new Event('change', {bubbles: true})); el.dispatchEvent(new Event('click', {bubbles: true})); }")
                                        
                                    time.sleep(1)
                                    print("    ✅ 已选择'特殊单' (多重触发保障)。")
                                    special_selected = True
                                    break
                            except:
                                continue
                        
                        time.sleep(1)
                        for confirm_round in range(2):
                            print(f"  -> 点击确认转异常 (第{confirm_round+1}次)...")
                            time.sleep(2)
                            click_confirmed = False
                            for frame in page.frames:
                                if click_confirmed:
                                    break
                                try:
                                    btn = frame.locator("input#confirm_confirm, span#confirmBtn, span.btn_1:has-text('确认'), span.btn_1:has-text('确定'), .layui-layer-btn0, .layui-layer-btn1, a:text-is('确定'), button:text-is('确定'), a:text-is('是'), button:text-is('是'), a.btn_1:text-is('是'), span.btn_1:text-is('是'), .layui-layer-btn a:text-is('是'), input[type='button'][value='是'], input.btn_1[value='是']").first
                                    if btn.count() > 0:
                                        btn.click(force=True, timeout=3000)
                                        time.sleep(1)
                                        print(f"    ✅ 已点击确认按钮 (第{confirm_round+1}次)。")
                                        click_confirmed = True
                                except:
                                    continue
                                    
                            if not click_confirmed:
                                print(f"    ℹ️ 第{confirm_round+1}次确认弹窗未出现。")
                                break
                            time.sleep(2)
                            
                        close_msg_dialog("转异常结果提示")
                        time.sleep(1)
                else:
                    print("  -> 未发现任何需要转异常的'预售'订单。")



        return True

    except Exception as e:
        print(f"  ❌ 任务异常: {e}")
        return False
    finally:
        if should_close:
            page.close()
            print("[ERP自动化] 标签页已关闭。\n")

if __name__ == "__main__":
    pass