crawler-plugin/app/amazon/asin_status.py

import time
import traceback
from datetime import datetime
import requests

from amazon.amazon_base import AmamzonBase, kill_process,TaskBase
from amazon.tool import show_notification

from config import runing_task, runing_shop, DELETE_BRAND_API_BASE


class AmzonePStatus(AmamzonBase):
    mark_name = "状态查询"

    def search_asin(self, asin):
        search_region = self.tab.ele('xpath://div[@id="searchBoxContainer"]//kat-input-group')
        search_region.wait.displayed(raise_err=False)
        time.sleep(0.6)
        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)
        sku_ls = []
        for _ in range(3):
            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.hidden(timeout=3, raise_err=False)
            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
        return sku_ls

    def search_asin_action(self, asin: str):
        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)

        sku_ls = self.search_asin(asin=asin)
        print(f"【{self.mark_name}】{asin} 搜索到 {len(sku_ls)} 个SKU")

    def clear_tab(self):
        all_tab = self.browser.get_tabs()
        close_tab = []
        for tab in all_tab:
            tab_id = tab if isinstance(tab, str) else tab.tab_id
            if self.tab.tab_id == tab_id:
                continue
            close_tab.append(tab)
        print("需要关闭的标签页", close_tab)
        print("当前操作的tab_id", self.tab.tab_id)
        self.browser.close_tabs(close_tab)

    def run_page_action(self, appoint_asin: str = None):
        self.log(f"==================={self.mark_name}=======================")
        self.log("开始执行...")
        num = 0
        retry_num = 0
        already_asin = set()
        get_page_faild = 0

        while retry_num < 3:  # 最多重试3次
            try:
                print(self.mark_name, "指定asin操作", appoint_asin)
                self.search_asin_action(asin=appoint_asin)

                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}")
                        get_page_faild = 0
                except Exception as e:
                    print("【{self.mark_name}】", "获取页码失败", e)
                    get_page_faild += 1
                    if get_page_faild > 2:
                        show_notification(f"【{self.mark_name}】获取页码失败超3次停止任务！")
                        break

                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]:
                if len(sku_ls) == 0:
                    yield (appoint_asin,"查询不到")
                    break

                for sku_ele in sku_ls:
                    asin = sku_ele.ele(
                        'xpath:.//div[contains(@class,"JanusSplitBox-module__container")]//div[contains(@class,"JanusSplitBox-module__panel--") and contains(string(.),"ASIN")]/..//div[last()]',
                        timeout=3).text
                    print(f"【{self.mark_name}】ASIN {asin} 找到....")
                    if asin in already_asin:
                        print(f"【{self.mark_name}】{asin} 已经处理过了，跳过")
                        continue

                    # 状态
                    status_ele = sku_ele.eles('xpath:.//div[contains(@class,"Status-module__container")]//kat-label')
                    if len(status_ele) > 0:
                        statu = status_ele[0].attr("emphasis")
                    else:
                        statu = "未获取到状态"

                    already_asin.add(asin)
                    yield (asin,statu)
                    print(f"【{self.mark_name}】",(asin,statu))

                # 判断是否存在需要翻页的情况
                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 StatusTask(TaskBase):
    task_name = "状态查询-TASK"

    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", [])[0]
            shop_name = items.get("shop_name")
            queryAsins = items.get("queryAsins", [])

            user_id = data.get("user_id")
            stage_index = data.get("stage_index")
            final_stage = bool(data.get("final_stage", True))

            # 用于测试
            limit = data.get("limit", None)

            if not task_id or not queryAsins:
                self.log("任务ID / queryAsins列表 为空，跳过", "WARNING")
                return

            self.log(f"开始处理审批任务 {task_id}，共 1 个店铺，{len(queryAsins)} 个国家")

            runing_task[task_id] = {
                "status": "running",
                "start_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "total_shops": 1,
                "processed_shops": 0,
                "total_countries": len(queryAsins),
                "processed_countries": 0,
                "total_asins": 0,
                "processed_asins": 0,
                "success_count": 0,
                "failed_count": 0,
                "stop_requested": False
            }

            # 检查是否收到暂停请求
            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

            self.log(f"开始处理店铺: {shop_name}")
            show_notification(f"开始处理店铺: {shop_name}", "info")

            try:
                self.process_shop(items, queryAsins, task_id,  user_id, stage_index,
                                  final_stage, limit=limit)

                # 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:
                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:
            self.log(f"任务处理失败: {traceback.format_exc()}", "ERROR")
            if task_id:
                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,
                     user_id=None, stage_index=None, final_stage: bool = True, limit: str = None):
        """处理单个店铺

        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次
        max_retries = 3
        iskill = False
        # 处理每个国家
        for value in country_codes:
            country_code = value.get("country")
            all_asin = value.get("asins")
            # 打开店铺
            driver = self.open_shop(cls=AmzonePStatus,max_retries=max_retries, company_name=company_name,
                                    shop_name=shop_name, iskill=iskill)
            if driver is None:
                self.log(f"任务 {task_id} 启动店铺失败，结束任务", "ERROR")
                for country_code in country_codes:
                    self.post_result(task_id, shop_name, country_code, "", "", is_done=True)
                return

            # 检查是否收到暂停请求
            if task_id in runing_task and runing_task[task_id].get("stop_requested", False):
                self.log(f"检测到任务 {task_id} 的暂停请求，停止处理国家", "ERROR")
                driver.close_store()
                break
            try:
                self.process_country(driver, country_code, task_id, shop_name,all_asin=all_asin )
            except Exception as e:
                self.log(f"处理国家 {country_code} 失败: {str(e)}", "ERROR")
                self.log(traceback.format_exc(), "ERROR")
                if "与页面的连接已断开" in str(e):
                    iskill = True

            # 更新已处理国家数
            if task_id in runing_task:
                runing_task[task_id]["processed_countries"] += 1

            # 关闭店铺
            driver.close_store()

        self.log(f"{task_id}任务处理完成")

        # 最后回传，标记完成
        try:
            # self.post_result(task_id, shop_name, country_code, "", "", is_done=True)
            if final_stage:
                self.post_result(task_id, shop_name, country_code, "", "", is_done=True)
            else:
                self.post_stage_finished(task_id, user_id, stage_index)
        except Exception as e:
            self.log(f"回传结果失败: {str(e)}", "ERROR")

        # 从正在执行中的店铺列表中移除
        if shop_name in runing_shop:
            del runing_shop[shop_name]
            self.log(f"店铺 {shop_name} 已从执行列表中移除")

    def process_country(self, driver: AmzonePStatus, country_code: str, task_id: int, shop_name: str,
                        all_asin:list,limit: str = None):
        """处理单个国家的审批任务

        Args:
            driver: AmzoneApprove驱动实例
            country_code: 国家代码（如 UK, DE, FR 等）
            task_id: 任务ID
            shop_name: 店铺名称
            risk_listing_filter: 风险商品筛选条件
        """

        # 转换国家代码为中文名称
        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 > 1:
                    # 刷新不行就重新打开店铺
                    self.log("重试前重新打开店铺...")
                    try:
                        driver.close_store()
                        time.sleep(3)
                        driver.open_shop(shop_name)
                    except Exception as e:
                        self.log(f"关闭重新打开店铺: {str(e)}", "WARNING")
                # 如果不是第一次尝试，先刷新页面
                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:
                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

        # 切换到库存管理页面
        for retry in range(max_retries):
            try:
                driver.SwitchPage()
                self.log(f"已切换到库存管理页面")
            except Exception as e:
                self.log(f"切换页面失败: {str(e)}", "ERROR")
                self.log(traceback.format_exc(), "ERROR")

                if retry >= max_retries - 1:
                    if task_id in runing_task:
                        runing_task[task_id]["processed_countries"] += 1
                    self.log(f"切换页面失败重试退出", "ERROR")
                    return

        # 处理所有需要审批的商品（通过yield获取结果）

        # 指定 asin
        for ap_asin in all_asin:
            print(f"【{driver.mark_name}】开始处理 ->",ap_asin)
            for asin, status in driver.run_page_action(
                    appoint_asin=ap_asin
            ):
                # 检查是否收到暂停请求
                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")

        self.log(f"国家 {country_name} 处理完成")

    def post_stage_finished(self, task_id: int, user_id, stage_index):
        # import requests
        # from config import DELETE_BRAND_API_BASE

        if user_id in (None, "", 0):
            raise ValueError("user_id is required for stage completion callback")
        if stage_index is None:
            raise ValueError("stage_index is required for stage completion callback")

        url = f"{DELETE_BRAND_API_BASE}/api/shop-match/tasks/{task_id}/stage-finished"
        payload = {"stage_index": stage_index}
        params = {"user_id": user_id}

        max_retries = 3
        for retry in range(max_retries):
            try:
                self.log(f"Attempting stage completion callback ({retry + 1}/{max_retries})")
                response = requests.post(
                    url,
                    params=params,
                    json=payload,
                    headers={"Content-Type": "application/json"},
                    timeout=30,
                    verify=False,
                )
                self.log(f"Stage completion callback response: {response.text}")
                data = response.json() if response.text else {}
                if response.status_code == 200 and isinstance(data, dict) and data.get("success"):
                    self.log(f"Stage completion callback succeeded: task={task_id}, stage={stage_index}")
                    return
                self.log(f"Stage completion callback failed, status={response.status_code}", "WARNING")
            except Exception as e:
                self.log(f"Stage completion callback exception: {str(e)}", "ERROR")
            if retry < max_retries - 1:
                time.sleep(2)

        raise RuntimeError(f"Stage completion callback failed after retries: task={task_id}, stage={stage_index}")

    def post_result(self, task_id: int, shop_name: str, country_code: str, asin: str, status: dict,
                    is_done: bool = False):
        """回传处理结果到API

        Args:
            task_id: 任务ID
            shop_name: 店铺名称
            country_code: 国家代码
            asin: ASIN
            status: 处理状态
        """

        url = f"{DELETE_BRAND_API_BASE}/api/query-asin/tasks/{task_id}/result"

        payload = {
          "shops": [
            {
              "shopName": shop_name,
              "countryResults": [
                {
                  "country": country_code,
                  "items": [
                    {
                      "asin": asin,
                      "status": status
                    }
                  ]
                }
              ],
              "shopDone": is_done,
              "submissionId": f"{int(time.time())}"
            }
          ]
        }
        if is_done:
            payload["shops"][0]["success"] = is_done

        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}")
                data = response.json() if response.text else {}
                if response.status_code == 200 and isinstance(data, dict) and data.get("success"):
                    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")
        raise RuntimeError("已达到最大重试次数，结果回传最终失败")



if __name__ == '__main__':
    # 使用示例
    user_info = {
        "company": "rongchuang123",
        "username": "自动化_Robot",
        "password": "#20zsg25"
    }
    shop_name = "魏振峰"
    country = "德国"
    kill_process('v6')
    driver = AmzonePStatus(user_info)
    browser = driver.open_shop(shop_name)
    sw_suc = driver.SwitchingCountries(country)
    driver.SwitchPage()
    risk_listing_filter = "Active"
    _shopMallName = "WEIZHENFENG168"
    ap_asin = "B0F1N18XFW"
    skip_asin = []
    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(
                current_shop_name=_shopMallName,
                appoint_asin=ap_asin, skip_asin=skip_asin
        ):
            print(f"ASIN {asin} 的处理结果: {status}")
        print("已完成操作")