python-qlv-helper 0.6.0__py3-none-any.whl → 0.9.3__py3-none-any.whl

qlv_helper/http/order_page.py

@@ -12,6 +12,7 @@
 import re
 import json
 import aiohttp
+from random import random
 from datetime import datetime
 from urllib.parse import quote
 from bs4 import BeautifulSoup, Tag
@@ -20,6 +21,7 @@ from typing import Dict, Any, Optional, List
 from qlv_helper.utils.type_utils import convert_cn_to_en
 from http_helper.client.async_proxy import HttpClientFactory
 from qlv_helper.utils.datetime_utils import get_current_dtstr
+from flight_helper.models.dto.procurement import FillProcurementInputDTO
 from qlv_helper.utils.type_utils import get_key_by_index, get_value_by_index, safe_convert_advanced
 
 
@@ -43,39 +45,52 @@ async def get_order_page_html(
     )
 
 
-async def fill_procurement_info_with_http(
-        *, order_id: int, qlv_domain: str, amount: float, pre_order_id: str, platform_user_id: str, user_password: str,
-        passengers: List[str], fids: str, pids: List[str], transaction_id: str, qlv_protocol: str = "http",
-        retry: int = 1, timeout: int = 5, enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None,
-        playwright_state: Dict[str, Any] = None, data_list: Optional[List[Dict[str, Any]]] = None
+async def fill_procurement_dto_with_http(
+        *, fill_procurement_dto: FillProcurementInputDTO, retry: int = 1, timeout: int = 5, enable_log: bool = True,
+        cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None,
+        data_list: Optional[List[Dict[str, Any]]] = None
 ) -> Dict[str, Any]:
     client = HttpClientFactory(
-        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, enable_log=enable_log, retry=retry,
-        cookie_jar=cookie_jar or aiohttp.CookieJar(),
-        playwright_state=playwright_state
+        protocol=fill_procurement_dto.pl_protocol, domain=fill_procurement_dto.pl_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
     )
 
     headers = {
         "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
-        "Referer": f"{qlv_protocol}://{qlv_domain}/OrderProcessing/NewTicket/{order_id}?&r={datetime.now().strftime("%Y%m%d%H%M%S")}",
+        "Referer": f"{fill_procurement_dto.pl_protocol}://{fill_procurement_dto.pl_domain}/OrderProcessing/NewTicket/{fill_procurement_dto.order_no}?&r={datetime.now().strftime("%Y%m%d%H%M%S")}",
     }
     if data_list:
         data = data_list
     else:
-        remark = f"{platform_user_id}/{user_password}"
-        pName = "," + ",".join(passengers) + ","
-        pids = ",".join(pids)
-        data = [
-            {"tradingDat": datetime.now().strftime("%Y-%m-%d %H:%M"), "outTktPF": "G航司官网", "outTktLoginCode": "",
-             "typeName": "VCC", "accountID": "8", "accountName": "VCC", "transactionAmount": f"{amount}",
-             "mainCheckNumber": "", "airCoOrderID": f"{pre_order_id}", "QuotaResultAmount": "0.00",
-             "remark": f"{quote(remark)}", "flightIdx": ",1,", "pName": f"{pName}", "orderID": f"{order_id}",
-             "businessTypeName": "机票", "tradingItems": "机票支出", "actualAmount": 0, "pType": "成人",
-             "fids": f"{fids}", "pids": f"{pids}", "iscandel": "true", "isbatch": "false",
-             "MainCheckNumberValus": f"{transaction_id}",
-             "OfficeNo": "", "PriceStdActual": "0.00", "ReturnAmount": "0.0000", "OffsetReturnAmount": "0.00",
-             "profitRemark": "", "preSaleType": "", "ErrorType": "", "OutTktPFTypeID": "34", "OutTicketAccount": "",
-             "OutTicketAccountID": "", "OutTicketPWD": "", "OutTicketTel": "", "OutTicketPNR": ""}
+        pName = "," + ",".join(
+            fill_procurement_dto.passenger_names) + "," if fill_procurement_dto.passenger_names else ''
+        pids = ",".join(fill_procurement_dto.passenger_ids) if fill_procurement_dto.passenger_ids else ''
+        data = [{
+            "tradingDat": datetime.now().strftime("%Y-%m-%d %H:%M"),
+            "outTktPF": f"{fill_procurement_dto.out_ticket_platform or ''}", "outTktLoginCode": "",
+            "typeName": f"{fill_procurement_dto.type_name or ''}",
+            "accountID": f"{fill_procurement_dto.purchase_account_id or ''}",
+            "accountName": f"{fill_procurement_dto.purchase_account or ''}",
+            "transactionAmount": f"{fill_procurement_dto.transaction_amount}",
+            "mainCheckNumber": "",
+            "airCoOrderID": f"{fill_procurement_dto.air_co_order_id}", "QuotaResultAmount": "0.00",
+            "remark": f"{quote(fill_procurement_dto.remark) or ''}",
+            "flightIdx": f",{fill_procurement_dto.segment_index or '1'},", "pName": f"{pName}",
+            "orderID": f"{fill_procurement_dto.order_no}",
+            "businessTypeName": "机票", "tradingItems": "机票支出", "actualAmount": 0,
+            "pType": f"{fill_procurement_dto.passenger_type}",
+            "fids": f"{fill_procurement_dto.flight_ids or ''}",
+            "pids": f"{pids or ''}",
+            "iscandel": "true", "isbatch": "false",
+            "MainCheckNumberValus": f"{fill_procurement_dto.pay_transaction}",
+            "OfficeNo": "", "PriceStdActual": "0.00", "ReturnAmount": "0.0000", "OffsetReturnAmount": "0.00",
+            "profitRemark": "", "preSaleType": "", "ErrorType": "",
+            "OutTktPFTypeID": f"{fill_procurement_dto.out_ticket_platform_type_id or ''}",
+            "OutTicketAccount": f"{fill_procurement_dto.out_ticket_account or ''}",
+            "OutTicketAccountID": f"{fill_procurement_dto.out_ticket_account_id or ''}",
+            "OutTicketPWD": f"{fill_procurement_dto.out_ticket_account_password or ''}",
+            "OutTicketTel": f"{fill_procurement_dto.out_ticket_mobile or ''}",
+            "OutTicketPNR": ""}
         ]
     data = f"list={json.dumps(data)}&isPayAll=true&delTransactionids=&OutTicketLossType&OutTicketLossRemark="
     return await client.request(
@@ -84,6 +99,150 @@ async def fill_procurement_info_with_http(
     )
 
 
+async def fill_remark_with_http(
+        *, remark: str, order_id: int, qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+    }
+    data = f"orderid={order_id}&remark={remark}"
+    return await client.request(
+        method="POST", url="/JPOrderCommon/SaveFreeRemark", headers=headers, is_end=True, data=data.encode("utf-8")
+    )
+
+
+async def update_policy_with_http(
+        *, policy_name: str, order_id: int, qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, old_policy_name: Optional[str] = None,
+        playwright_state: Dict[str, Any] = None,
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+    }
+    data = f"OrderID={order_id}&PolicyName={policy_name}&OldPolicyName="
+    if old_policy_name is not None:
+        data = f"{data}{old_policy_name}"
+    return await client.request(
+        method="POST", url="/OrderProcessing/EditPolicyName", headers=headers, is_end=True, data=data.encode("utf-8")
+    )
+
+
+async def locked_order_with_http(
+        *, order_id: int, qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+
+    result = await client.request(method="GET", url=f"/OrderProcessing/Ticket/{order_id}", is_end=True)
+    if "操作提示" in result.get("message", ""):
+        soup = BeautifulSoup(result.get("data"), 'html.parser')
+        h3_tag = soup.find('h3')
+        if h3_tag:
+            text = h3_tag.get_text(strip=True)
+            if text:
+                result["data"] = text
+    return result
+
+
+async def unlock_order_with_http(
+        *, order_id: int, qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+
+    return await client.request(
+        method="GET", url=f"/OrderProcessing/UnLock/{order_id}?s={random()}", is_end=True
+    )
+
+
+async def forced_unlock_order_with_http(
+        *, order_id: int, qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+
+    return await client.request(
+        method="GET", url=f"/OrderProcessing/UnLockForce/{order_id}?s={random()}", is_end=True
+    )
+
+
+async def fill_itinerary_with_http(
+        *, order_id: int, qlv_domain: str, pid: str, tid: str, transaction_id: str, itinerary_id: str, retry: int = 1,
+        qlv_protocol: str = "http", timeout: int = 5, enable_log: bool = True, data: Optional[str] = None,
+        cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, enable_log=enable_log, retry=retry,
+        cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        "Referer": f"{qlv_protocol}://{qlv_domain}/OrderProcessing/NewTicket_show/{order_id}?&r={datetime.now().strftime("%Y%m%d%H%M%S")}",
+    }
+    if not data:
+        data = f"OrderID={order_id}&OrderPID={pid}&OrderTID={tid}&TicketNo={itinerary_id}&ZJTransactionID={transaction_id}"
+    return await client.request(
+        method="POST", url="/OrderProcessing/TicketNoSave",
+        headers=headers, is_end=True, data=data.encode("utf-8")
+    )
+
+
+async def kick_out_activity_order_with_http(
+        *, order_id: int, qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+    }
+    data = f"ID={order_id}"
+    return await client.request(
+        method="POST", url=f"/OrderList/KickOutActivityOrders", is_end=True, data=data.encode("utf-8"), headers=headers
+    )
+
+
+async def kick_out_activity_orders_with_http(
+        *, order_ids: List[int], qlv_protocol: str, qlv_domain: str, retry: int = 1, timeout: int = 5,
+        enable_log: bool = True, cookie_jar: Optional[aiohttp.CookieJar] = None, playwright_state: Dict[str, Any] = None
+) -> Dict[str, Any]:
+    client = HttpClientFactory(
+        protocol=qlv_protocol, domain=qlv_domain, timeout=timeout, retry=retry,
+        enable_log=enable_log, cookie_jar=cookie_jar or aiohttp.CookieJar(), playwright_state=playwright_state
+    )
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+    }
+    order_ids_str = ",".join(str(id) for id in order_ids) + ","
+    data = f"OrderIDS={order_ids_str}"
+    return await client.request(
+        method="POST", url=f"/OrderList/YJTCActivityOrders", is_end=True, data=data.encode("utf-8"), headers=headers
+    )
+
+
 def order_info_static_headers() -> OrderedDict[str, str]:
     return OrderedDict([
         ("receipted_ota", "OTA实收"),  # 0
@@ -199,6 +358,7 @@ def flight_extend_headers() -> OrderedDict[str, str]:
         ("code_arr", " 抵达机场"),  # 11
         ("pid", "乘客ID"),  # 12
         ("fid", "航段ID"),  # 13
+        ("tid", "乘客表ID"),  # 14
     ])
 
 
@@ -350,7 +510,10 @@ def parse_order_flight_table_row(
 ) -> Dict[str, Any]:
     """解析航班表每一行的数据"""
     tds = tr.find_all("td", recursive=False)
-    values = {get_key_by_index(index=12, ordered_dict=extend_headers): tr["pid"]}
+    values = {
+        get_key_by_index(index=12, ordered_dict=extend_headers): tr["pid"],
+        get_key_by_index(index=14, ordered_dict=extend_headers): tr["tid"]
+    }
     for idx, td in enumerate(tds):
         if idx >= len(headers):
             continue

qlv_helper/po/domestic_activity_order_page.py

@@ -23,6 +23,96 @@ class DomesticActivityOrderPage(BasePo):
         super().__init__(page, url)
         self.__page = page
 
+    async def get_flight_table_locator(self, timeout: float = 5.0) -> Locator:
+        """
+        获取table
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=//table[@class="table table_hover table_border  table_center"]//tbody'
+        return await self.get_locator(selector=selecor, timeout=timeout)
+
+    async def get_flight_table_trs_locator(self, timeout: float = 5.0) -> Locator:
+        """
+        获取table所有tr locator对象
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=//table[@class="table table_hover table_border  table_center"]/tbody/tr'
+        return await self.get_locator(selector=selecor, timeout=timeout)
+
+    async def get_flight_table_tds_th(self, locator: Locator, timeout: float = 5.0) -> Locator:
+        """
+        获取table所有tr下的th locator对象
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./th'
+        return await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+
+    async def get_flight_table_trs_td(self, locator: Locator, timeout: float = 5.0) -> Locator:
+        """
+        获取table所有tr下的td locator对象
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./td'
+        return await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+
+    async def get_flight_table_td_order_id(self, locator: Locator, timeout: float = 5.0) -> str:
+        """
+        获取table 行中的订单id
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./a'
+        locator = await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+        return (await locator.inner_text()).strip()
+
+    async def get_flight_table_td_urgant(self, locator: Locator, timeout: float = 5.0) -> str:
+        """
+        获取table 行中的紧急状态
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./font'
+        locator = await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+        return (await locator.inner_text()).strip()
+
+    async def get_flight_table_td_operation_lock_btn(self, locator: Locator, timeout: float = 5.0) -> Locator:
+        """
+        获取table 行中的锁单按钮
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./a'
+        return await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+
+    async def get_flight_table_td_operation_pop_btn(self, locator: Locator, timeout: float = 5.0) -> Locator:
+        """
+        获取table 行中的剔出按钮
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./button'
+        return await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+
+    async def get_flight_table_td_operation_substitute_btn(self, locator: Locator, timeout: float = 5.0) -> Locator:
+        """
+        获取table 行中的补位按钮
+        :param locator:
+        :param timeout:
+        :return:
+        """
+        selecor: str = 'xpath=./a'
+        return await self.get_sub_locator(locator=locator, selector=selecor, timeout=timeout)
+
     async def get_flight_table(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
         try:
             locator = self.__page.locator(self.__table_selector)
@@ -84,6 +174,7 @@ class DomesticActivityOrderPage(BasePo):
     3. 主流程：分页 + 每页解析 tbody
     ------------------------------------------------------------
     """
+
     async def parse_table_with_pagination(self, refresh_wait_time: float = 10.0) -> List[Dict[str, Any]]:
         """
         refresh_wait_time: 翻页后等待时间

qlv_helper/po/login_page.py

@@ -11,8 +11,7 @@
 """
 from typing import Tuple, Union
 from playwright_helper.libs.base_po import BasePo
-from qlv_helper.utils.ocr_helper import get_image_text
-from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError, Locator
+from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError, Locator, ElementHandle
 
 
 class LoginPage(BasePo):
@@ -22,104 +21,67 @@ class LoginPage(BasePo):
         super().__init__(page, url)
         self.__page = page
 
-    async def get_login_username_input(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_login_username_input(self, timeout: float = 5.0) -> Locator:
         """
         获取登录页面的用户名输入框
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
         selector: str = '//input[@id="UserName"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【用户名】输入框'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_login_password_input(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_login_password_input(self, timeout: float = 5.0) -> Locator:
         """
         获取登录页面的密码输入框
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
         selector: str = '//input[@id="Password"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【密码】输入框'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_login_number_code_input(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_captcha(self, timeout: float = 5.0) -> Locator:
         """
-        获取登录页面的数字验证码输入框，第一层验证码
+        获取验证码Locator对象
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
-        selector: str = '//input[@id="Code"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【数字验证码】输入框'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        selector: str = 'xpath=//div[@class="form_row"]/img[@onclick="this.src=this.src+\'?\'"]'
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_login_btn(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    @staticmethod
+    async def get_captcha_type(locator: Locator, timeout: float = 5.0) -> int:
         """
-        获取登录页面的登录按钮
+        获取验证码的类型
+        :param locator: 验证码Locator对象
         :param timeout: 超时时间（秒）
         :return: (是否存在, 错误信息|元素对象)
-        :return:
         """
-        selector: str = '//input[@class="login-btn"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到登录页面中的【登录】按钮'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        img_src: str = await locator.get_attribute(name="src", timeout=timeout)
+        img_src_slice = img_src.split("=")
+        return int(img_src_slice[-1][0])
 
-    async def get_number_code(self, timeout: float = 5.0) -> Tuple[bool, str]:
+    async def get_captcha_image(self, timeout: float = 5.0) -> ElementHandle:
         selector: str = '//div[@id="signup_forms"]//img'
-        return await get_image_text(page=self.__page, selector=selector, timeout=timeout)
+        locator: Locator = await self.get_locator(selector=selector, timeout=timeout)
+        return await locator.element_handle(timeout=timeout * 1000)
 
-    async def is_exist_login_warn(self, timeout: float = 5.0) -> bool:
-        selector: str = '//p[@class="login_warn"]'
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                text: str = await locator.text_content(timeout=timeout * 1000)
-                if text.strip() != "":
-                    return True
-                else:
-                    return False
-            else:
-                return False
-        except (PlaywrightTimeoutError, Exception):
-            return False
+    async def get_login_captcha_input(self, timeout: float = 5.0) -> Locator:
+        """
+        获取登录页面的验证码输入框
+        :param timeout: 超时时间（秒）
+        :return: (是否存在, 错误信息|元素对象)
+        """
+        selector: str = '//input[@id="Code"]'
+        return await self.get_locator(selector=selector, timeout=timeout)
+
+    async def get_login_btn(self, timeout: float = 5.0) -> Locator:
+        """
+        获取登录页面的登录按钮
+        :param timeout: 超时时间（秒）
+        :return: (是否存在, 错误信息|元素对象)
+        """
+        selector: str = '//input[@class="login-btn"]'
+        return await self.get_locator(selector=selector, timeout=timeout)
 
     async def get_wechat_entrance(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
         selector: str = '//img[@src="/images/weixin.png"]'

qlv_helper/po/main_page.py

@@ -9,9 +9,8 @@
 # Copyright ©2011-2025. Hunan xxxxxxx Company limited. All rights reserved.
 # ---------------------------------------------------------------------------------------------------------
 """
-from typing import Tuple, Union
+from playwright.async_api import Page, Locator
 from playwright_helper.libs.base_po import BasePo
-from playwright.async_api import Page, TimeoutError as PlaywrightTimeoutError, Locator
 
 
 class MainPage(BasePo):
@@ -23,48 +22,18 @@ class MainPage(BasePo):
         self.url = url
         self.__page = page
 
-    async def get_confirm_btn_with_system_notice_dialog(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_confirm_btn_with_system_notice_dialog(self, timeout: float = 5.0) -> Locator:
         """
         获取系统通知弹框中的确认按钮，注意这个地方，存在多个叠加的弹框，因此用last()方法，只需定位到最上面的那个弹框就行
         :return:
         """
         selector: str = "//div[@class='CommonAlert'][last()]//a[@class='CommonAlertBtnConfirm']"
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到首页中的【系统提醒-确定】按钮'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_level1_menu_order_checkout(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_level1_menu_order_checkout(self, timeout: float = 5.0) -> Locator:
         selector: str = "//span[contains(normalize-space(), '订单出票')]"
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到首页中的【订单出票】左侧一级导航菜单'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)
 
-    async def get_level2_menu_order_checkout(self, timeout: float = 5.0) -> Tuple[bool, Union[Locator, str]]:
+    async def get_level2_menu_order_checkout(self, timeout: float = 5.0) -> Locator:
         selector: str = "//a[@menuname='国内活动订单']"
-        try:
-            locator = self.__page.locator(selector)
-            if locator:
-                await locator.wait_for(state='visible', timeout=timeout * 1000)
-                return True, locator
-            else:
-                return False, '没有找到首页中的【国内活动订单】左侧二级导航菜单'
-        except PlaywrightTimeoutError:
-            return False, f"元素 '{selector}' 未在 {timeout} 秒内找到"
-        except Exception as e:
-            return False, f"检查元素时发生错误: {str(e)}"
+        return await self.get_locator(selector=selector, timeout=timeout)

qlv_helper/po/order_detail_page.py

@@ -263,7 +263,7 @@ class OrderDetailPage(BasePo):
         :return: (是否存在, 错误信息|元素对象)
         """
         selector: str = '//a[@id="alertMsg_btnConfirm"]/cite'
-        return await self.get_locator(selector=selector, timeout=timeout)
+        return await self.get_locator(selector=selector, timeout=timeout, strict=False)
 
     async def get_policy_input(self, timeout: float = 5.0) -> Locator:
         """
@@ -273,3 +273,48 @@ class OrderDetailPage(BasePo):
         """
         selector: str = '//legend//input[@name="PolicyName"]'
         return await self.get_locator(selector=selector, timeout=timeout)
+
+    async def get_purchase_info_transaction_id(self, timeout: float = 5.0) -> List[str]:
+        """
+        获取订单详情页面的采购信息流水
+        :param timeout:
+        :return:
+        """
+        # selector: str = '//tr[@class="PurchaseInfoClass"]'
+        selector: str = '//table[@id="PurchaseInfos"]/tbody/tr'
+        loc: Locator = await self.get_locator(selector=selector, timeout=timeout)
+        locators = await loc.all()
+        transaction_ids = list()
+        for locator in locators:
+            transaction_id = await locator.get_attribute("transactionid")
+            if transaction_id:
+                transaction_ids.append(transaction_id.strip())
+        return transaction_ids
+
+    async def get_relation_order_detail_link(self, timeout: float = 5.0) -> Locator:
+        """
+        获取关联订单的详情链接
+        :param timeout: 超时时间
+        :return:
+        """
+        selector: str = 'xpath=//span[contains(text(), "关联订单")]/../a'
+        return await self.get_locator(selector=selector, timeout=timeout)
+
+    async def get_message_alert(self, timeout: float = 5.0) -> Locator:
+        """
+        获取详情页面消息弹框
+        :param timeout: 超时时长
+        :return:
+        """
+        selector: str = 'xpath=//a[@id="alertMsg_btnConfirm"]/cite/../..'
+        return await self.get_locator(selector=selector, timeout=timeout)
+
+    async def get_message_content(self, timeout: float = 5.0) -> str:
+        """
+        获取详情页面消息弹框
+        :param timeout: 超时时长
+        :return:
+        """
+        selector: str = 'xpath=//a[@id="alertMsg_btnConfirm"]/cite/../../p'
+        locator = await self.get_locator(selector=selector, timeout=timeout)
+        return (await locator.inner_text()).strip()