path: root/common/ui_common/objects/accounts.py

# -*- coding: UTF-8 -*-
import configparser
import re
import time

import pytest
from selenium.webdriver import ActionChains
from selenium.common.exceptions import StaleElementReferenceException
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from common.driver_common.mywebdriver import MyWebDriver
from selenium.webdriver.common.by import By

from common.ui_common.profiles.profiles_public_operations import ProfilesPublicOperations
from config.workpath import workdir
from page_element.profiles_element_position import *
from page_element.objects_element_position import *
from common.driver_common.screenshot import screenshot_on_failure
from common.driver_common.random_name import RandomName

from selenium import webdriver
from common.ui_common.login_logout.loginout import LogInOut
from common.read_data.read_data import ReadData
from selenium.webdriver.common.keys import Keys
import random
import os
from common.ui_common.objects.objects_public_operations import ObjectsPublicOperations, download_files, \
    get_txt_filenames


class Accounts:
    def __init__(self, demo_fixture: MyWebDriver):
        self.workdir = workdir
        self.my_random = RandomName()
        self.random_name = self.my_random.random_name()  # 生成随机Name
        self.random_account = self.my_random.random_account()  # 生成随机account
        self.driver = demo_fixture
        self.my_files = ReadData()
        # 调用object公共方法操作、删除、查询，
        self.objects_po = ObjectsPublicOperations(self.driver)
        self.loginout_parse = configparser.ConfigParser()
        loginout_parse_dir = os.path.join(workdir, "config", "loginout.ini")
        self.loginout_parse.read(loginout_parse_dir, encoding="utf-8")
        self.profile_pub = ProfilesPublicOperations(self.driver)
        self.wait = WebDriverWait(self.driver, 10)
        self.my_count = 0

    @screenshot_on_failure
    def acc_case(self, data: {}):
        try:
            self._create(data)  # 新建
            if data["Model"].strip().lower() == "modify":  # 修改测试时，执行修改方法
                self._query(data, require_assertion=1)  # 创建后查询
                self._modify(data)  # 修改
                # self._query(data, require_assertion=2)
        except Exception as e:
            raise e
        finally:
            self._del(data)  # 删除

    @screenshot_on_failure
    def _goto_accountsPage(self):
        # 调用消除右上提示弹窗
        self.objects_po.dismiss_rightTopTips(mainPage_rightTopTips_closeButton_posXpath)
        # 菜单操作 跳转到accounts页面
        # self.driver.find_element(By.CSS_SELECTOR, mainPage_navigationBar_logo_posCss).click()
        # 切换Vsys 至UIvsys
        # vsys_name = self.loginout_parse.get("vsys", "vsys_name")  # 登录后vsys切换为UIAutoTestVsys
        # # print(vsys_name)
        # profile_pub = ProfilesPublicOperations(self.driver)
        # profile_pub.change_vsys(vsys_name=vsys_name)
        # profile_pub.change_vsys(vsys_name="UIAutoTestVsys")
        self.driver.isElementExist("//div[@class='MuiListItem-root MuiListItem-gutters Mui-selected menu-account-object css-1l56wwh']")
        if self.driver.Exist:
            self.driver.find_element(By.XPATH,"//div[@class='MuiListItem-root MuiListItem-gutters Mui-selected menu-account-object css-1l56wwh']").click()
        else:
            self.driver.find_element(By.XPATH, mainPage_firstLevelMenu_Objects_posXpath).click()
            self.driver.implicitly_wait(2)
            self.driver.find_element(By.XPATH, mainPage_secondLevelMenu_Account_posXpath).click()
        time.sleep(3)

    @screenshot_on_failure
    def _just_goto_accountsPage(self):

        self.driver.isElementExist("//div[@class='MuiListItem-root MuiListItem-gutters Mui-selected menu-account-object css-1l56wwh']")
        if self.driver.Exist:
            self.driver.find_element(By.XPATH,"//div[@class='MuiListItem-root MuiListItem-gutters Mui-selected menu-account-object css-1l56wwh']").click()
        else:
            self.driver.find_element(By.XPATH, mainPage_firstLevelMenu_Objects_posXpath).click()
            self.driver.implicitly_wait(2)
            self.driver.find_element(By.XPATH, mainPage_secondLevelMenu_Account_posXpath).click()
            # 增加首次进入时验证Total和首行是否存在
            if self.my_count == 0:
                total_text = self.driver.find_element(By.XPATH, main_listPage_object_bottomTotal_postXpath).text
                total_value = int(total_text.split(":")[-1].strip())
                is_first_exist = self.driver.element_isExist(By.XPATH, list_first_row_first_column_posXpath)
                try:
                    assert is_first_exist or total_value == 0, "校验失败！！列表页为空！！"
                except AssertionError:
                    time.sleep(1)
                    total_text = self.driver.find_element(By.XPATH, main_listPage_object_bottomTotal_postXpath).text
                    total_value = int(total_text.split(":")[-1].strip())
                    is_first_exist = self.driver.element_isExist(By.XPATH, list_first_row_first_column_posXpath)
                    assert is_first_exist or total_value == 0, "校验失败！！列表页为空！！"
                self.my_count += 1
        time.sleep(3)

    @screenshot_on_failure
    def _create(self, data):
        # 跳转至对象创建页面
        self._just_goto_accountsPage()
        # self._goto_accountsPage()
        # 选择创建模式，single or group
        self._create_type(data)
        # 页面选项操作
        self._operate_page(data, operation_type="create")

        self._object_detail_page_save()
        self.first_elems_table = self.objects_po.extract_ele()  # 获取列表页第一列信息

    @screenshot_on_failure
    def _create_type(self, data, item_name=None):
        self.object_type = object_type = data["Type"]
        # 点击Create
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()
        if object_type == 0:  # 如为单独对象而非Object Group则继续，否则else
            # 点击Created下的Account
            self.driver.find_element(By.XPATH, acc_listPage_createButton_account_posId).click()
            # 进入Create Account页面
        else:
            print("crating Account Group !!!")
            # 点击Created下的Account Group
            self.driver.find_element(By.XPATH, acc_listPage_createButton_accountGroup_posId).click()
            # 进入Create Account Group页面

    def _operate_page(self, data, operation_type="create", no_modify=False):
        if operation_type == "create":
            data_index = 0  # 新增数据索引
        else:
            data_index = -1  # 编辑数据索引
        # no_modify = False
        if self.object_type == 0:  # single Object
            self._operate_name(data, no_modify=no_modify)
            self._operate_object_statistics(data, no_modify=no_modify)
            self._operate_items(data, data_index=data_index, no_modify=no_modify)
            self._operate_description(data, no_modify=no_modify)
        else:  # Object group
            self._operate_name(data, no_modify=no_modify)
            self._operate_subordinate_objects(data, data_index=data_index, no_modify=no_modify)
            self._operate_exclude_objects(data, data_index=data_index)
            self._operate_description(data, no_modify=no_modify)

    def _operate_object_statistics(self, data, no_modify):
        if no_modify:  # 不执行操作(修改）
            return 0
        try:
            my_object_statistics = data["Object Statistics"]
        except:
            my_object_statistics = 'None'
        if my_object_statistics == "":  # data中object_statistics为空，则选用随机
            my_object_statistics = self.objects_po.random_object_statistics
        if my_object_statistics != "None":
            self._select_object_statistics(my_object_statistics)  # 选择statistic Type
            self.my_object_statistics = my_object_statistics

    @screenshot_on_failure
    def _select_object_statistics(self, my_object_statistics):
        # 展开下拉框
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_objectStatistics_dropDown_posXpath).click()
        if my_object_statistics == "Elaborate":
            self.driver.find_element(By.XPATH, acc_ObjectDetailPage_objectStatistics_elaborate_posXpath).click()
        elif my_object_statistics == "Brief":
            self.driver.find_element(By.XPATH, acc_ObjectDetailPage_objectStatistics_brief_posXpath).click()
        else:
            pass  # 默认为None

    def _just_operate_name(self, data, no_modify):
        if no_modify:  # 不执行操作(修改）
            return 0
        my_item_name = data["Name"]
        if my_item_name == "":  # data中name为空，则选用随机name
            my_item_name = self.random_name
        return my_item_name

    def _operate_name(self, data, no_modify):
        if no_modify:  # 不执行操作(修改）
            return 0
        my_item_name = data["Name"]
        if my_item_name == "":  # data中name为空，则选用随机name
            my_item_name = self.random_name
        self._input_name(my_item_name)  # 键入Name动作
        self.my_item_name = my_item_name

    def _operate_sub_name(self, data, item_value):
        my_sub_item_name = data["Subordinate Objects"]["subName"]
        if my_sub_item_name == "":  # data中name为空，则选用随机name
            my_sub_item_name = self.random_name
        trans_item_value = str(item_value)
        my_sub_item_name = "{}-of {}".format(my_sub_item_name, trans_item_value)
        # self._input_sub_name(my_sub_item_name)  # 键入Name动作
        self.my_sub_item_name = my_sub_item_name
        return my_sub_item_name

    def _operate_exclude_name(self, data, item_value):
        my_exclude_item_name = data["Exclude Objects"]["subName"]
        if my_exclude_item_name == "":  # data中name为空，则选用随机name
            my_exclude_item_name = self.random_name
        trans_item_value = str(item_value)
        my_exclude_item_name = "{}-of {}".format(my_exclude_item_name, trans_item_value)
        # self._input_sub_name(my_sub_item_name)  # 键入Name动作
        self.my_exclude_item_name = my_exclude_item_name
        return my_exclude_item_name

    @screenshot_on_failure
    def _input_name(self, my_item_name):
        self.objects_po.clear_Name(acc_ObjectDetailPage_nameInput_posXpath)  # 清空输入框
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_nameInput_posXpath).send_keys(
            my_item_name)  # 于Name输入框键入Name

    @screenshot_on_failure
    def _input_sub_name(self, my_sub_item_name):
        self.objects_po.clear_Name(
            acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_nameInput_posXpath)  # 清空输入框
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_nameInput_posXpath).send_keys(
            my_sub_item_name)  # 于Name输入框键入Name

    # def _operate_items(self, data, data_index=0, no_modify=False):
    #     if no_modify:  # 不执行操作(修改）
    #         return 0
    #     data_values = data["Items"]
    #     for i in range(len(data_values)):
    #         data_cate = data_values[i].split("->")[data_index].strip()  # 要操作的数据
    #         if data_cate != no_modify:  # 编辑时不修改则跳过
    #             if data_cate == "":  # 为空时，跳过
    #                 continue
    #             elif data_cate == "[删除]":  # 执行删除命令
    #                 old_data = data_values[i].split("->")[0].strip()
    #                 if old_data == "[random]":
    #                     old_data = self.random_account
    #                 # else:
    #                 #     # old_data = data_values[i].split("->")[0].strip()
    #                 self._items_acc_del(old_data)
    #             elif data_values[i].split("->")[0].strip() == "[random]":  # random->表示新增对象value值为随机
    #                 # if data_values[i].split("->")[0].strip() == "[random]":
    #                 data_cate = self.random_account
    #                 self._items_acc_add(data_cate)
    #                 # else:
    #                 #     data_cate = self.random_account
    #                 #     # self._items_cate_add(data_cate)
    #             elif data_cate[-8:] == "[search]":  # cabkjk[search]-> 表示创建并搜索该对象
    #                 data_cate = data_values[i].split("->")[0].strip()[:-8]
    #                 if data_cate == "[random]":
    #                     data_cate = self.random_account
    #                     self._items_acc_add(data_cate)
    #                     self._items_acc_search(search_value=data_cate)
    #                 else:
    #                     self._items_acc_add(data_cate)
    #                     self._items_acc_search(search_value=data_cate)
    #             elif data_cate[-16:] == "[ImportFromFile]":  # abc.txt[ImportFromFile]->表示文件导入方式添加Item
    #                 data_file_name = data_values[i].split("->")[0].strip()[:-16]
    #                 self._items_acc_add_from_file(data_file_name)
    #                 self._interim_4_items_acc_add_from_file()  # interim steps
    #                 # 借search方法校验是否上传成功，及上传数据是否正确
    #                 with open(self.my_files._obj_files_path(file_name=data_file_name), "r") as f:  # 打开文件
    #                     item_data = f.readline()  # 读取文件第一行内容
    #                     # print(item_data)  # 打印文件第一行内容
    #                 self._items_acc_search(search_value=item_data)
    #             else:  # 新增数据或者修改数据
    #                 if data_index == -1:  # 修改数据
    #                     old_data = data_values[i].split("->")[0].strip()  # 创建的数据，修改前的数据
    #                     if old_data == "":  # ->abc的格式数据，表示修改中的新增
    #                         self._items_acc_add(data_cate)
    #                     elif old_data == "[random]":  # [random]->abc的格式数据，表示原数据为随机生成
    #                         old_data = self.random_account
    #                         self._items_acc_modify(old_data, data_cate)
    #                     elif data_cate == "[random]":  # sdsd->[random]表示修改对象value值为随机
    #                         data_cate = self.my_random.random_account()
    #                         self._items_acc_modify(old_data, data_cate)
    #                     else:  # adbc->csd.com  表示修改原数据
    #                         self._items_acc_modify(old_data, data_cate)
    #                 else:  # 新增数据  asdnkj->
    #                     self._items_acc_add(data_cate)
    #
    # def _operate_subordinate_objects(self, data, data_index=0, no_modify=False):
    #     if no_modify:  # 不执行操作(修改）
    #         return 0
    #     sub_name = data["Subordinate Objects"]["subName"]
    #     sub_description = data["Subordinate Objects"]["subDescription"]
    #     data_values = data["Subordinate Objects"]["subItems"]
    #     for i in range(len(data_values)):
    #         data_cate = data_values[i].split("->")[data_index].strip()  # 要操作的数据
    #         if data_cate != no_modify:  # 编辑时不修改则跳过
    #             if data_cate == "":  # 为空时，跳过
    #                 continue
    #             elif data_cate == "[删除]":  # 执行删除命令
    #                 old_data = data_values[i].split("->")[0].strip()
    #                 self._sub_items_acc_del(old_data)
    #             elif data_values[i].split("->")[0].strip() == "[random]":  # random->表示新增对象value值为随机
    #                 # if data_values[i].split("->")[0].strip() == "[random]":
    #                 print('data_values[i].split("->")[0].strip() == "[random]"')
    #                 data_cate = self.random_account
    #                 self._sub_objects_acc_add(data, data_cate)
    #                 ################
    #                 # 使用切片和连接的方法来创建一个新的字符串
    #                 new_string = str(self.random_account) + "->" + "->".join(data_values[i].split("->")[1:])
    #                 # 重新赋值给data_values[i]
    #                 data_values[i] = new_string
    #                 ################
    #                 # else:
    #                 #     data_values[i] = self.random_account
    #             else:  # 新增数据或者修改数据
    #                 if data_index == -1:  # 修改数据
    #                     old_data = data_values[i].split("->")[0].strip()  # 创建的数据，修改前的数据
    #                     if old_data == "":  # ->abc的格式数据，表示修改中的新增
    #                         print('old_data == ""')
    #                         self._sub_objects_acc_add(data, data_cate)
    #                     elif old_data == "[random]":  # [random]->abc的格式数据，表示原数据为随机生成
    #                         old_data = self.random_account
    #                         self._operate_sub_items_modify(data, old_data, data_cate)
    #                     elif data_cate == "[random]":  # sdsd->[random]表示修改对象value值为随机
    #                         data_cate = self.my_random.random_account()
    #                         self._operate_sub_items_modify(data, old_data, data_cate)
    #                     else:  # adbc->csd.com  表示修改原数据
    #                         self._operate_sub_items_modify(data, old_data, data_cate)
    #                 else:  # 新增数据  asdnkj->
    #                     self._sub_objects_acc_add(data, data_cate)
    def _operate_items(self, data, data_index=0, no_modify=False):
        if no_modify:  # 不执行操作(修改）
            return 0
        data_values = data["Items"]
        for i in range(len(data_values)):
            data_acc = data_values[i].split("->")[data_index].strip()  # 要操作的数据
            if data_acc != no_modify:  # 编辑时不修改则跳过
                if data_acc == "":  # 为空时，跳过
                    continue
                elif data_acc == "[删除]":  # 执行删除命令
                    old_data = data_values[i].split("->")[0].strip()
                    if old_data == "[random]":
                        old_data = self.random_account
                    # else:
                    #     # old_data = data_values[i].split("->")[0].strip()
                    self._items_acc_del(old_data)
                elif data_acc[-8:] == "[search]":  # cabkjk[search]-> 表示创建并搜索该对象
                    data_acc = data_values[i].split("->")[0].strip()[:-8]
                    if data_acc == "[random]":
                        data_acc = self.random_account
                    self._items_acc_add(data_acc)
                    # self._items_acc_search(search_pos="single", search_value=data_acc)
                elif data_acc[-16:] == "[ImportFromFile]":  # abc.txt[ImportFromFile]->表示文件导入方式添加Item
                    data_file_name = data_acc[:-16]
                    self._items_acc_add_from_file(data_file_name)
                    self._interim_4_items_acc_add_from_file()  # interim steps
                    # 借search方法校验是否上传成功，及上传数据是否正确
                    with open(self.my_files._obj_files_path(file_name=data_file_name), "r",
                              encoding='utf-8') as f:  # 打开文件
                        item_datas = f.readlines()  # 读取文件所有行内容
                        item_data = item_datas[random.randint(1, len(item_datas)) - 1].replace("\\n",
                                                                                               "").strip()  # 任选一行的数据
                    # self._items_acc_search(search_pos="single", search_value=item_data)
                elif "&" in data_values[i].split("->")[0].strip():  # 一条Item中加多个数据：
                    # print("#一条Item中加多个数据")
                    item_value_list = []
                    item_data = data_values[i].split("->")[0].strip()
                    for i in range(item_data.count("&") + 1):
                        item_value = item_data.split("&")[i].strip()
                        item_value_list.append(item_value)
                    # print(item_value_list)
                    item_value = item_value_list
                    self._items_acc_add(item_value, single_or_multi=2)
                else:  # 新增数据或者修改数据
                    if data_index == -1:  # 修改数据
                        old_data = data_values[i].split("->")[0].strip()  # 创建的数据，修改前的数据
                        if old_data == "":  # ->abc的格式数据，表示修改中的新增
                            if data_acc == "[random]":
                                data_acc = self.my_random.random_account()
                            self._items_acc_add(data_acc)
                        elif old_data == "[random]":  # [random]->abc的格式数据，表示原数据为随机生成
                            old_data = self.random_account
                            self._items_acc_modify(old_data, data_acc)
                        elif data_acc == "[random]":  # sdsd->[random]表示修改对象value值为随机
                            data_acc = self.my_random.random_account()
                            self._items_acc_modify(old_data, data_acc)
                        else:  # adbc->csd.com  表示修改原数据
                            self._items_acc_modify(old_data, data_acc)
                    else:  # 新增数据  asdnkj->
                        if data_acc == "[random]":  # random->表示新增对象value值为随机
                            data_acc = self.random_account
                        self._items_acc_add(data_acc)

    def _operate_subordinate_objects(self, data, data_index=0, no_modify=False):
        if no_modify:  # 不执行操作(修改）
            return 0
        data_values = data["Subordinate Objects"]["subItems"]
        for i in range(len(data_values)):
            data_acc = data_values[i].split("->")[data_index].strip()  # 要操作的数据
            if data_acc != no_modify:  # 编辑时不修改则跳过
                if data_acc[-8:] == "[search]":  # cabkjk[search]-> 表示创建并搜索该对象
                    data_acc = data_acc[:-8]
                    self.search_sub_obj = True
                else:
                    self.search_sub_obj = False
                ###################################################
                if data_acc == "":  # 为空时，跳过
                    continue
                elif data_acc == "[删除]":  # 执行删除命令
                    old_data = data_values[i].split("->")[0].strip()
                    self._sub_items_acc_del(old_data)
                    ################
                else:  # 新增数据或者修改数据
                    try:
                        search_sub_obj = self.search_sub_obj
                    except:
                        search_sub_obj = False
                    if data_index == -1:  # 修改数据
                        old_data = data_values[i].split("->")[0].strip()  # 创建的数据，修改前的数据
                        if old_data == "":  # ->abc的格式数据，表示修改中的新增
                            if data_acc == "[random]":  # sdsd->[random]表示修改对象value值为随机
                                data_acc = self.my_random.random_account()
                            self._sub_objects_acc_add(data, data_acc)
                        elif old_data == "[random]":  # [random]->abc的格式数据，表示原数据为随机生成
                            old_data = self.random_account
                            self._operate_sub_items_modify(data, old_data, data_acc)
                        else:  # adbc->csd.com  表示修改原数据
                            if data_acc == "[random]":  # sdsd->[random]表示修改对象value值为随机
                                data_acc = self.my_random.random_account()
                            self._operate_sub_items_modify(data, old_data, data_acc)
                        if search_sub_obj:
                            pass
                            # self._items_acc_search(search_pos="sub",
                            #                        search_value=self._operate_sub_name(data, data_acc))
                    else:  # 新增数据  asdnkj->
                        if data_acc == "[random]":  # random->表示新增对象value值为随机
                            data_acc = self.random_account
                            self._sub_objects_acc_add(data, data_acc)
                            # 使用切片和连接的方法来创建一个新的字符串
                            new_string = str(self.random_account) + "->" + "->".join(data_values[i].split("->")[1:])
                            # 重新赋值给data_values[i]
                            data_values[i] = new_string
                        else:
                            self._sub_objects_acc_add(data, data_acc)
                        if search_sub_obj:
                            pass
                            # self._items_acc_search(search_pos="sub",
                            #                        search_value=self._operate_sub_name(data, data_acc))

    @screenshot_on_failure
    def _items_acc_del(self, item_value):
        # 点击要删除的数据按钮操作
        acc_item_del_btn_xpath = "//*[normalize-space(text())='{}']/ancestor::div[@class='form-list-row css-xpbhx9']//i[@class='iconfont icon-Delete_X']".format(item_value)
        self.driver.find_element(By.XPATH, acc_item_del_btn_xpath).click()

    @screenshot_on_failure
    def _sub_items_acc_del(self, item_name):
        # 点击要删除的数据按钮操作
        sub_acc_item_del_btn_xpath = "(//*[normalize-space(text())='{}']/ancestor::div[@class='form-list-row css-xpbhx9']//i[@class='iconfont icon-Delete_X text-[18px] text-[--color-text]')[1]".format(
            item_name)
        self.driver.find_element(By.XPATH, sub_acc_item_del_btn_xpath).click()

    _exclude_sub_items_acc_del = _sub_items_acc_del

    @screenshot_on_failure
    def _items_acc_add(self, item_value, single_or_multi=1):
        """

        :param item_value: 数据值
        :param single_or_muti: 1--一个Item一条数据，2--一个Item多条数据
        :return:
        """
        # 点击items "+"按钮
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_item_addButton_poXpath).click()  # 点击“+”按钮
        if single_or_multi == 1:  # 一个Item一条数据
            # 在空内容的输入框中，输入新增的数据
            for item in item_value:
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemValueInput_poXpath).send_keys(item)  # 于Item value输入框键入上述item_value
        else:  # 一个Item多条数据
            for single_item_value in item_value:
                for item in item_value:
                    self.driver.find_element(By.XPATH,"({})[last()]".format(acc_ObjectDetailPage_itemValueInput_poXpath)).send_keys(item)  # 于Item value输入框键入上述item_value
                if single_item_value == item_value[-1]:
                    break
                else:
                    self.driver.find_element(By.XPATH,
                                             acc_ObjectDetailPage_item_subAddButton_poId).click()  # 点击单个Item中新增多条数据的"+"按钮
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemSaveButton_poXpath).click()  # 点击保存按钮

    @screenshot_on_failure
    def _items_acc_add_from_file(self, data_file_name):
        # print(data_file_name)
        # 点击Import From File
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_importFromFile_posXpath).click()
        # 于Please Upload input 上传文件
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_pleaseUpload_posXpath).send_keys(
            self.my_files._obj_files_path(file_name=data_file_name))
        self.driver.implicitly_wait(5)
        time.sleep(2)
        # Import 侧滑页面校验
        self._verify_import_drawer_result(data_file_name)
        # 点击OK button
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_importUrlOk_posXpath).click()
        # 获取页面item值并校验
        return data_file_name

    def _verify_import_drawer_result(self, data_file_name):
        """
        import 侧滑页面校验
        :param data_file_name:
        :return:
        """
        from collections import Counter
        value_pos = acc_ObjectDetailPage_importDrawer_importTipsValue_posXpath_template
        # 页面Import Tips中获取结果
        valid_num = int(self.driver.find_element(By.XPATH, ObjectDetailPage_importDrawer_importTipsValue_Valid_posXpath).text)
        invalid_format_num = int(self.driver.find_element(By.XPATH,ObjectDetailPage_importDrawer_importTipsValue_InvalidFormat_posXpath).text)
        duplicate_within_file_num = int(self.driver.find_element(By.XPATH,ObjectDetailPage_importDrawer_importTipsValue_Duplicates_current_file_posXpath).text)
        duplicate_within_existing_num = int(self.driver.find_element(By.XPATH,ObjectDetailPage_importDrawer_importTipsValue_Duplicates_global_objects_posXpath).text)
        total_num = int(self.driver.find_element(By.XPATH, ObjectDetailPage_importDrawer_importTipsValue_Total_posXpath).text)
        # 页面 importTable中获取结果
        failed_items_num_in_import_table = len(self.driver.find_elements(By.XPATH, ObjectDetailPage_importDrawer_importTable_Failed_items_posXpath))
        total_num_in_import_table = int(self.driver.find_element(By.XPATH, ObjectDetailPage_importDrawer_importTable_Total_posXpath).text[6:])
        # 文件中统计结果
        with open(self.my_files._obj_files_path(file_name=data_file_name), "r",
                  encoding='utf-8') as f:  # 打开文件
            lines = f.readlines()
            total_num_in_file = len(lines)  # 对应total_num
            # 统计每行出现的次数
            line_counts = Counter(lines)
            # 重复数据条数
            duplicate_num_in_file = sum(
                count - 1 for count in line_counts.values() if count > 1)  # 对应duplicate_within_file_num

        # 对比结果
        assert valid_num == total_num_in_file - (
                duplicate_num_in_file + invalid_format_num) == total_num_in_import_table - failed_items_num_in_import_table

    @screenshot_on_failure
    def _interim_4_items_acc_add_from_file(self):
        """
        实现对象详情页面内OK->对象列表内选择并编辑再次进入对象详情页
        :return:
        """
        self._object_detail_page_save()
        # notLoading_elem_xpath = self.driver.element_isExist(By.XPATH,global_loading_elem_whenNotDisplaied_xpath)
        # print("是否不在加载：{}".format(is_exist_notLoading_elem_xpath))
        # while not notLoading_elem_xpath:  # 加载
        #     # print("Loading！")
        #     notLoading_elem_xpath = self.driver.element_isExist(By.XPATH,global_loading_elem_whenNotDisplaied_xpath)
        #     if notLoading_elem_xpath:
        #         # print("加载完毕")
        #         break
        self.first_row_checkBox_element = self.driver.find_element(By.XPATH,listPage_select_first_object_posXpath).click()  # 勾选第一行元素
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
        # return item_data

    @screenshot_on_failure
    def _sub_objects_acc_add(self, data, item_value):
        # self.driver.implicitly_wait(5)
        while True:
            self.driver.isElementExist('//div[@class="EditDraw"]//div[@class="el-loading-mask"]')
            if not self.driver.Exist:
                break
        self.driver.find_element(By.XPATH, "//div[@class='MuiBox-root css-nfknh2']//label[text()='Subordinate Objects']").click()
        # 判断是否存在Subordinate Objects 下的"+"按钮
        if self.objects_po.is_element_clickable(acc_ObjectGroupDetailPage_subObjects_addButton_normalAdd_posXpath,
                                                "XPATH"):
            print("有数据新建")
            # 点击Subordinate Objects 下的"+"按钮
            self.driver.find_element(By.XPATH,
                                     acc_ObjectGroupDetailPage_subObjects_addButton_normalAdd_posXpath).click()
        else:
            print("无数据新建")
            # 点击Subordinate Objects 下的"+"按钮
            self.driver.find_element(By.XPATH, acc_ObjectGroupDetailPage_subObjects_addButton_newAdd_posXpath).click()
        time.sleep(0.5)
        # 点击Accounts侧滑窗口的"+"按钮
        self.driver.find_element(By.XPATH, acc_ObjectGroupDetailPage_subObjects_toggleDraw_addButton_posXpath).click()
        time.sleep(0.5)
        # 点击Accounts侧滑窗口的"+"按钮下的Account
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_toggleDraw_addButton_account_posXpath).click()
        my_sub_item_name = self._operate_sub_name(data, item_value)  # name
        self._input_sub_name(my_sub_item_name)  # 键入name
        self._sub_items_acc_add(item_value)  # items
        self._operate_sub_description(data)  # description
        self._sub_object_detail_page_save()

    def _add_sub_objects_by_search(self):
        # self.driver.implicitly_wait(5)
        while True:
            self.driver.isElementExist('//div[@class="EditDraw"]//div[@class="el-loading-mask"]')
            if not self.driver.Exist:
                break
        self.driver.find_element(By.XPATH, '//div[@data-desc="subObject"]/label').click()
        # 判断是否存在Subordinate Objects 下的"+"按钮
        if self.objects_po.is_element_clickable(acc_ObjectGroupDetailPage_subObjects_addButton_normalAdd_posXpath,
                                                "XPATH"):
            print("有数据新建")
            # 点击Subordinate Objects 下的"+"按钮
            self.driver.find_element(By.XPATH,
                                     acc_ObjectGroupDetailPage_subObjects_addButton_normalAdd_posXpath).click()
        else:
            print("无数据新建")
            # 点击Subordinate Objects 下的"+"按钮
            self.driver.find_element(By.XPATH, acc_ObjectGroupDetailPage_subObjects_addButton_newAdd_posXpath).click()
        # 侧滑页面搜索并添加对应Object
        self.driver.find_element(By.XPATH, urlGroup_ObjectDetailPage_subItemSearch_posXpath).send_keys(
            self.my_item_name)
        self.driver.find_element(By.XPATH, urlGroup_ObjectDetailPage_subItemSearch_posXpath).send_keys(Keys.ENTER)
        self.driver.find_element(By.XPATH, url_ObjectDetailPage_firstUrlObject).click()  # 选择第一个Object

    @screenshot_on_failure
    def _exclude_sub_objects_acc_add(self, data, item_value):
        # while True:
        #     self.driver.isElementExist('//div[@class="EditDraw"]//div[@class="el-loading-mask"]')
        #     if not self.driver.Exist:
        #         break
        # 判断 Exclude Objects 按钮是否处于开启状态
        if self.driver.element_isExist(By.XPATH, accGroup_ObjectDetailPage_excludeObjectsSwitch_enableStatus_posXpath):
            print("有数据新建")
            # 点击Exclude Objects 下的"+"按钮
            self.driver.find_element(By.XPATH,
                                     acc_ObjectGroupDetailPage_excludeObjects_addButton_normalAdd_posXpath).click()
        else:
            print("无数据新建")
            # Enable Exclude Objects
            exclude_objects_switch_elem = self.driver.find_element(By.XPATH,
                                                                   accGroup_ObjectDetailPage_excludeObjectsSwitch_posXpath)
            exclude_objects_switch_elem.click()
            # 点击Exclude Objects 下的"+"按钮
            self.driver.find_element(By.XPATH,
                                     acc_ObjectGroupDetailPage_excludeObjects_addButton_newAdd_posXpath).click()
        time.sleep(0.5)
        # 点击Accounts侧滑窗口的"+"按钮
        self.driver.find_element(By.XPATH, acc_ObjectGroupDetailPage_subObjects_toggleDraw_addButton_posXpath).click()
        time.sleep(0.5)
        # 点击Accounts侧滑窗口的"+"按钮下的Account
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_toggleDraw_addButton_account_posXpath).click()
        my_exclude_item_name = self._operate_exclude_name(data, item_value)  # name
        self._input_sub_name(my_exclude_item_name)  # 键入name
        self._sub_items_acc_add(item_value)  # items
        self._operate_exclude_description(data)  # description
        self._sub_object_detail_page_save()

    @screenshot_on_failure
    def _sub_items_acc_add(self, item_value):
        # 点击侧滑子Create Account页面中Items下的"+"按钮
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_itemsAddButton_posXpath).click()
        for i in item_value:
        # 于侧滑子Create Account页面中Items下的item value输入框键入 item_value
            self.driver.find_element(By.XPATH,
                                     acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_itemsValueInput_posXpath).send_keys(i)
        # 点击侧滑子Create Account页面中Items下的保存按钮
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_itemsValueSaveButton_posXpath).click()

    @screenshot_on_failure
    def _items_acc_modify(self, old_value, new_value):
        # print("modifying！！！！！！！！！！！")
        # if new_value == "[random]":
        #     new_value = self.my_random.random_account()
        # 点击要修改数据的编辑按钮操作
        acc_item_edit_btn_xpath = "//*[normalize-space(text())='{}']/ancestor::div[@class='form-list-row css-xpbhx9']//i[@class='iconfont icon-Edit']".format(old_value)
        self.driver.find_element(By.XPATH, acc_item_edit_btn_xpath).click()
        # 清空要编辑修改数据的输入框内容
        acc_item_input_xpath = "//input[@value='{}']".format(old_value)
        self.driver.find_element(By.XPATH, acc_item_input_xpath).clear()
        # 清空后键入新数据
        for i in new_value:
            self.driver.find_element(By.XPATH, acc_item_input_xpath).send_keys(i)
        # 保存
        acc_item_save_btn_xpath = acc_ObjectDetailPage_itemSaveButton_poXpath
        self.driver.find_element(By.XPATH, acc_item_save_btn_xpath).click()

    def _operate_sub_items_modify(self, data, old_value, new_value):
        print("_operate_sub_items_modify!!")
        self._sub_items_acc_modify(data, old_value, new_value)
        # 点击Edit object侧滑页面中的OK button
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_posXpath).click()
        # 点击确认弹窗的YES
        # self.driver.find_element(By.XPATH,
        #                          acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_yes_posXpath).click()

    def _operate_exclude_items_modify(self, data, old_value, new_value):
        self._exclude_items_acc_modify(data, old_value, new_value)
        # 点击Edit object侧滑页面中的OK button
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_posXpath).click()
        # 点击确认弹窗的YES
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_yes_posXpath).click()

    @screenshot_on_failure
    def _sub_items_acc_modify(self, data, old_value, new_value):
        my_sub_item_name = self._operate_sub_name(data, old_value)
        time.sleep(0.5)
        # 点击要修改数据的编辑按钮操作
        sub_acc_object_edit_btn_xpath = "(//*[normalize-space(text())='{}']/ancestor::li[contains(@class,'list-none truncate relative')]//i[contains(@class,'icon-Edit')])[1]".format(
            my_sub_item_name)
        print("my_sub_item_name:{}".format(my_sub_item_name))
        self.driver.find_element(By.XPATH, sub_acc_object_edit_btn_xpath).click()
        print("clicked sub_acc_object_edit_btn")
        # 进入Edit Interval侧滑页面
        # 点击要修改数据的编辑按钮操作
        sub_acc_item_edit_btn_xpath = '//div[@class="items"]//i[@class="iconfont icon-Edit"]'
        print("old_value:{}".format(old_value))
        self.driver.implicitly_wait(6)
        self.driver.find_element(By.XPATH, sub_acc_item_edit_btn_xpath).click()
        # 清空要编辑修改数据的输入框内容
        sub_acc_item_input_xpath = '//input[@class="MuiInput-input css-1u0jcuo"]'
        self.driver.find_element(By.XPATH, sub_acc_item_input_xpath).clear()
        # 清空后键入新数据
        for i in new_value:
            self.driver.find_element(By.XPATH, sub_acc_item_input_xpath).send_keys(i)
        # 保存
        sub_acc_item_save_btn_xpath = acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_itemsValueSaveButton_posXpath
        self.driver.find_element(By.XPATH, sub_acc_item_save_btn_xpath).click()

    @screenshot_on_failure
    def _exclude_items_acc_modify(self, data, old_value, new_value):
        my_exclude_item_name = self._operate_exclude_name(data, old_value)
        time.sleep(0.5)
        # 点击要修改数据的编辑按钮操作
        exclude_acc_object_edit_btn_xpath = "(//*[normalize-space(text())='{}']/ancestor::li[contains(@class,'list-none truncate relative')]//i[contains(@class,'icon-Edit')])[1]".format(
            my_exclude_item_name)
        # print("my_sub_item_name:{}".format(my_exclude_item_name))
        self.driver.find_element(By.XPATH, exclude_acc_object_edit_btn_xpath).click()
        # print("clicked sub_acc_object_edit_btn")
        # 进入Edit Interval侧滑页面
        # 点击要修改数据的编辑按钮操作
        exclude_acc_item_edit_btn_xpath = "(//*[normalize-space(text())='{}']/ancestor::*[@class='view-row']//i[contains(@class, 'iconfont icon-Edit')])[1]".format(
            old_value)
        print("old_value:{}".format(old_value))
        self.driver.implicitly_wait(6)
        self.driver.find_element(By.XPATH, exclude_acc_item_edit_btn_xpath).click()
        # 清空要编辑修改数据的输入框内容
        exclude_acc_item_input_xpath = '//input[@class="MuiInput-input css-1u0jcuo"]'
        self.driver.find_element(By.XPATH, exclude_acc_item_input_xpath).clear()
        # 清空后键入新数据
        for i in new_value:
            self.driver.find_element(By.XPATH, exclude_acc_item_input_xpath).send_keys(i)
        # 保存
        exclude_acc_item_save_btn_xpath = acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_itemsValueSaveButton_posXpath
        self.driver.find_element(By.XPATH, exclude_acc_item_save_btn_xpath).click()

    @screenshot_on_failure
    def _items_acc_search(self, search_pos, search_value):
        """
        Item 搜索框执行搜索操作并断言
        :param search_pos: 上层传递的 search_pos,搜索位置（Single Object中的Items搜索框、Group Object中的Sub/Exclude Items搜索框）
        :param search_value: 上层传递的search_value
        :return:
        """
        self.driver.find_element(By.XPATH, "//label[@class='MuiFormLabel-root css-1ptlcam']").click()
        operated_search_value = self._operate_item_search(search_value)
        # 定位搜索框并清除内容
        if search_pos == "single":
            total_text_pos = acc_ObjectDetailPage_itemsTotal_posXpath
            acc_ObjectDetailPage_object_search_elem = self.driver.find_element(By.XPATH,
                                                                               acc_ObjectDetailPage_item_search_posXpath)
            # acc_ObjectDetailPage_object_value_pos = '//div[@class="item-box"]//*[normalize-space(text())="{}"]'.format(
            #     search_value)
            items_values_pos = acc_ObjectDetailPage_itemsText_posXpath
        elif search_pos == "sub":
            total_text_pos = acc_ObjectDetailPage_itemsTotal_posXpath

            acc_ObjectDetailPage_object_search_elem = self.driver.find_element(By.XPATH,
                                                                               urlGroup_ObjectDetailPage_subObjectSearchButton_posXpath)
            # acc_ObjectDetailPage_object_value_pos = '//div[@class="CommonSubObjects"]//*[@class="row-content-cell" and normalize-space(text())="{}"]'.format(
            #     search_value)
            items_values_pos = acc_ObjectGroupDetailPage_subObjects_posXpaths
        else:  # search_pos =="exclude":
            total_text_pos = urlGroup_ObjectDetailPage_excludeTotal_posXpath
            acc_ObjectDetailPage_object_search_elem = self.driver.find_element(By.XPATH,
                                                                               urlGroup_ObjectDetailPage_excludeObjectSearchButton_posXpath)
            # acc_ObjectDetailPage_object_value_pos = '//div[@data-desc="exclude subObject"]//div[@class="CommonSubObjects"]//*[@class="row-content-cell" and normalize-space(text())="{}"]'.format(
            #     search_value)
            items_values_pos = acc_ObjectGroupDetailPage_excludeObjects_posXpaths
        # 搜索前的Total值
        origin_items_total = self.wait.until(
            EC.presence_of_element_located((By.XPATH, total_text_pos))).text  # Total 值
        origin_items_total = int(origin_items_total)

        acc_ObjectDetailPage_object_search_elem.clear()  # 清空输入框
        # 搜索框中键入搜索值
        acc_ObjectDetailPage_object_search_elem.send_keys(operated_search_value)
        # 确认并执行搜索
        acc_ObjectDetailPage_object_search_elem.send_keys(Keys.ENTER)  # 输入框中执行回车
        # 判断列表中是否存在被搜索项
        items_value_elems_list = self.driver.find_elements(By.XPATH, items_values_pos)
        items_value = random.choice(items_value_elems_list)
        # acc_ObjectDetailPage_object_value_elem = self.driver.find_element(By.XPATH,
        #                                                                   acc_ObjectDetailPage_object_value_pos)
        # print(acc_ObjectDetailPage_object_value_elem.text, search_value)
        assert search_value in items_value.text, "校验查询内容是否正确"
        # 搜索完的Total值
        items_total = self.driver.find_element(By.XPATH, total_text_pos).text  # Total 值
        items_total = int(items_total.split(":")[-1].strip())
        if origin_items_total == items_total:
            if origin_items_total > 1:
                items_text_list = [elem.text for elem in items_value_elems_list]
                for i in items_text_list:
                    assert search_value in i, "校验失败！！"
        else:
            assert items_total >= 1 and items_total < origin_items_total, "校验失败！！筛选前Total：{}，筛选后Total：{}".format(
                origin_items_total, items_total)

    def _operate_item_search(self, search_value):
        """
        处理过的search_value
        :param search_value:上层传递的search_value
        :return:处理过的search_value
        """
        if search_value[0] == "*" or search_value[0] == "$":
            search_value = search_value[1:]
            return search_value
        elif search_value[-1] == "*":
            search_value = search_value[:-1]
            return search_value
        else:
            return search_value

    def _operate_description(self, data, no_modify):
        if no_modify:  # 不执行操作(创建/修改）
            return 0
        my_item_description = data["Description"]
        if my_item_description == "":
            my_item_description = "This is Description for {}".format(self.my_item_name)
        self._input_description(my_item_description)
        self.my_item_description = my_item_description

    def _operate_sub_description(self, data):
        my_sub_item_description = data["Subordinate Objects"]["subDescription"]
        if my_sub_item_description == "":
            my_sub_item_description = "This is Description for {}".format(self.my_sub_item_name)
        self._input_sub_description(my_sub_item_description)
        self.my_sub_item_description = my_sub_item_description

    def _operate_exclude_description(self, data):
        my_exclude_item_description = data["Exclude Objects"]["subDescription"]
        if my_exclude_item_description == "":
            my_exclude_item_description = "This is Description for {}".format(self.my_exclude_item_name)
        self._input_sub_description(my_exclude_item_description)
        self.my_exclude_item_description = my_exclude_item_description

    @screenshot_on_failure
    def _input_description(self, my_item_description):
        # self.driver.implicitly_wait(5)
        while True:
            self.driver.isElementExist('//div[@class="EditDraw"]//div[@class="el-loading-mask"]')
            if not self.driver.Exist:
                break
        self.driver.find_element(By.XPATH, "//label[@class='MuiFormLabel-root css-1ptlcam']").click()
        # 定位description元素
        description_elem = self.driver.find_element(By.XPATH, acc_ObjectDetailPage_description_posXpath)
        # 清空输入框
        description_elem.clear()
        # 键入description
        description_elem.send_keys(my_item_description)

    @screenshot_on_failure
    def _input_sub_description(self, my_sub_item_description):
        # 定位description元素
        sub_description_elem = self.driver.find_element(By.XPATH,
                                                        acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_descriptionTextarea_posXpath)
        # 清空输入框
        sub_description_elem.clear()
        # 键入description
        sub_description_elem.send_keys(my_sub_item_description)

    @screenshot_on_failure
    def _object_detail_page_save(self):
        time.sleep(2)
        # 点击home 页OK
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
        # acc_ObjectDetailPage_okButton_yes_elem = self.driver.find_element(By.XPATH,
        #                                                                   acc_ObjectDetailPage_okButton_yes_posXpath)
        # # 点击确认弹窗的“Yes”按钮
        # if acc_ObjectDetailPage_okButton_yes_elem.is_displayed():
        #     acc_ObjectDetailPage_okButton_yes_elem.click()

    @screenshot_on_failure
    def _sub_object_detail_page_save(self):
        # 点击侧滑子Create Account页面中OK按钮
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_posXpath).click()  # 点击“OK”按钮
        self.driver.find_element(By.XPATH, '//i[@class="iconfont icon-Clear_aNormal close-icon"]').click()
        # 点击侧滑子Create Account页面确认弹窗的“Yes”按钮
        # subCreateAccountDrawer_okButton_yes = self.driver.find_element(By.XPATH,
        #                                                                acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_yes_posXpath)
        # if subCreateAccountDrawer_okButton_yes.is_displayed():
        #     subCreateAccountDrawer_okButton_yes.click()

    def _operate_exclude_objects(self, data, data_index=0):
        """
        处理data并操作Exclude Objects
        :param data:
        :param data_index:
        :return:
        """
        if "Exclude Objects" in data and data["Exclude Objects"] != "":
            data_values = data["Exclude Objects"]["subItems"]
            for i in range(len(data_values)):
                data_acc = data_values[i].split("->")[data_index].strip()  # 要操作的数据
                if data_acc[-8:] == "[search]":  # cabkjk[search]-> 表示创建并搜索该对象
                    data_acc = data_acc[:-8]
                    self.search_exclude_obj = True
                else:
                    self.search_exclude_obj = False
                ###################################################
                if data_acc == "":  # 为空时，跳过
                    continue
                elif data_acc == "[删除]":  # 执行删除命令
                    old_data = data_values[i].split("->")[0].strip()
                    self._exclude_sub_items_acc_del(old_data)
                    ################
                else:  # 新增数据或者修改数据
                    try:
                        search_exclude_obj = self.search_exclude_obj
                    except:
                        search_exclude_obj = False
                    if data_index == -1:  # 修改数据
                        old_data = data_values[i].split("->")[0].strip()  # 创建的数据，修改前的数据
                        if old_data == "":  # ->abc的格式数据，表示修改中的新增
                            print('old_data == ""')
                            if data_acc == "[random]":  # ->[random]表示修改对象value值为随机
                                data_acc = self.my_random.random_account()
                            self._exclude_sub_objects_acc_add(data, data_acc)
                        elif old_data == "[random]":  # [random]->abc的格式数据，表示原数据为随机生成
                            old_data = self.random_account
                            self._operate_exclude_items_modify(data, old_data, data_acc)
                        else:  # adbc->csd.com  表示修改原数据
                            if data_acc == "[random]":  # sdsd->[random]表示修改对象value值为随机
                                data_acc = self.my_random.random_account()
                            self._operate_exclude_items_modify(data, old_data, data_acc)
                        if search_exclude_obj:
                            pass
                            # self._items_acc_search(search_pos="exclude",
                            #                        search_value=self._operate_sub_name(data, data_acc))
                    else:  # 新增数据  asdnkj->
                        if data_acc == "[random]":  # random->表示新增对象value值为随机
                            # if data_values[i].split("->")[0].strip() == "[random]":
                            # print('data_values[i].split("->")[0].strip() == "[random]"')
                            data_acc = self.random_account
                            self._exclude_sub_objects_acc_add(data, data_acc)
                            # 使用切片和连接的方法来创建一个新的字符串
                            new_string = str(self.random_account) + "->" + "->".join(data_values[i].split("->")[1:])
                            # 重新赋值给data_values[i]
                            data_values[i] = new_string
                        else:
                            self._exclude_sub_objects_acc_add(data, data_acc)
                        if search_exclude_obj:
                            pass
                            # self._items_acc_search(search_pos="exclude",
                            #                        search_value=self._operate_sub_name(data, data_acc))

    @screenshot_on_failure
    def _query(self, data, search_type="Name", search_value=None, **kwargs):
        # 跳转至Objects Account页面
        self._just_goto_accountsPage()
        # self.objects_po.extract_ele()  # 获取列表页第一列信息
        if search_type and search_value:
            disable_search_value, disable_search_type, fuzzy_search = self._operate_acc_objects_search(data)  # 确定搜索值
        else:
            if search_value:
                disable_search_value, search_type, fuzzy_search = self._operate_acc_objects_search(data)  # 确定搜索值
            else:
                search_value, search_type, fuzzy_search = self._operate_acc_objects_search(data)  # 确定搜索值
        print("search_value:{} |||| search_type:{}".format(search_value, search_type))
        self._acc_objects_search(search_value, search_type, fuzzy_search)  # 执行搜索动作
        time.sleep(1)
        self._query_verify(search_value=search_value, search_type=search_type)  # 校验

    @screenshot_on_failure
    def _simple_query(self, data, search_value, **kwargs):
        self.go_to_page()
        simple_query = True
        # 跳转至acc页面
        if search_value:
            disable_search_value, search_type, fuzzy_search = self._operate_acc_objects_search(data,
                                                                                               simple_query)  # 确定搜索值
        else:
            search_value, search_type, fuzzy_search = self._operate_acc_objects_search(data,
                                                                                       simple_query)  # 确定搜索值
        self._acc_objects_search(search_value, search_type, fuzzy_search)  # 执行搜索动作

    @screenshot_on_failure
    def _simple_query_4_nest(self, search_value):
        self._acc_objects_search(search_value, search_type="Name", fuzzy_search=False)  # 执行搜索动作

    def _operate_acc_objects_search(self, data, simple_query=False):
        if simple_query:
            search_type = "Name"
        else:
            search_type = data["Search type"]
        try:
            fuzzy_search = data["fuzzy_search"]
            if fuzzy_search == "True":
                fuzzy_search = True
            else:
                fuzzy_search = False
        except:
            fuzzy_search = False
        random_full_or_part = random.randint(0, 1)
        # random_full_or_part = 1
        if search_type == "Name" or search_type == "":
            search_type = "Name"
            search_value = self.my_item_name
            if not simple_query and not fuzzy_search and random_full_or_part == 1:
                search_value = search_value[1:]
        elif search_type == "Description":
            search_value = self.my_item_description
            if not simple_query and not fuzzy_search and random_full_or_part == 1:
                search_value = search_value[1:]
        elif search_type == "Created By":
            skip_flag = 1
            if skip_flag == 1:
                pytest.skip("Created By 暂时略过")  # 暂时略过
            else:
                loginout_parse = configparser.ConfigParser()
                loginout_parse_dir = os.path.join(workdir, "config", "loginout.ini")
                loginout_parse.read(loginout_parse_dir, encoding="utf-8")
                login_name = loginout_parse.get("ui_account_1", "username")
                # print(login_name)
                search_value = login_name
        else:
            # 先用name方式搜索，获取对应信息
            self._acc_objects_search(self.my_item_name, search_type="Name", fuzzy_search=False)
            # 等待加载完成
            notLoading_elem_xpath = self.driver.element_isExist(By.XPATH,
                                                                global_loading_elem_whenNotDisplaied_xpath)
            while not notLoading_elem_xpath:
                # print("Loading！")
                notLoading_elem_xpath = self.driver.element_isExist(By.XPATH,
                                                                    global_loading_elem_whenNotDisplaied_xpath)
                if notLoading_elem_xpath:
                    # print("加载完毕")
                    break
            # self.objects_po.extract_ele()  # 获取列表页第一列信息
            if not simple_query and search_type == "Details":
                time.sleep(0.5)
                details_first_value_elem = self.wait.until(EC.presence_of_element_located(
                    (By.XPATH, acc_listPage_object_tableDetails_detailsRow_firstDetailValue_posXpaths)))
                details_first_value = details_first_value_elem.text
                search_value = details_first_value
                if not simple_query and not fuzzy_search and random_full_or_part == 1:
                    search_value = search_value[1:]
            elif not simple_query and search_type == "ID":
                search_value = self.objects_po.table_dict["ID"]
            else:
                print("非规范搜索方式，改用Name")
                search_type = "Name"
                search_value = self.my_item_name
                if not simple_query and not fuzzy_search and random_full_or_part == 1:
                    search_value = search_value[1:]
        # print("search_value:{} |||| search_type:{}".format(search_value, search_type))
        if not simple_query and fuzzy_search and random_full_or_part == 1:
            if search_type == "Name" or search_type == "Description" or search_type == "Details":
                start = end = len(search_value)
                # 设置最短5个字符
                while end - start < min(5, len(search_value)):
                    start = random.randint(0, len(search_value) - 1)
                    end = random.randint(start, len(search_value))
                search_value = search_value[start:end]
        else:  # search_value不做处理
            search_value = search_value
        return search_value, search_type, fuzzy_search

    @screenshot_on_failure
    def _acc_objects_search(self, search_value, search_type, fuzzy_search):
        acc_objects_search_input_posXpath = listpage_search_box_posXpath
        acc_objects_search_input_elem = self.driver.find_element(By.XPATH, acc_objects_search_input_posXpath)
        # 清空输入框
        try:
            searchClear = '//*[@id="searchClear"]'
            self.driver.isElementExist(searchClear)  # 列表页搜索框清空按钮
            if self.driver.Exist:
                self.driver.find_element(By.XPATH, searchClear).click()  # 点击清空搜索内容按钮
            else:  # 如无，则跳过
                pass
        except Exception as e:
            print(e)
        self.objects_po.clear_name_by_id(acc_objects_search_input_posXpath)
        if fuzzy_search:  # 随机方式全局模糊搜索
            acc_objects_search_input_elem.send_keys(search_value)  # 键入搜索值
            self.driver.find_element(By.XPATH, listpage_globalSearch_posXpath).click()
            random_enter = random.randint(0, 1)
            # random_enter = 1
            if random_enter == 0:  # 使用ENTER 确认搜索值
                print("随机全局模糊搜索-ENTER")
                # 确认内容
                acc_objects_search_input_elem.send_keys(Keys.ENTER)  # 确认输入框内容
            else:  # 鼠标点击确认搜索值
                print("随机全局模糊搜索-Mouse Click")
                self.driver.find_element(By.XPATH, listpage_search_button_posXpath).click()  # 点击搜索按钮
        else:  # 精确属性的搜索
            acc_objects_search_input_elem.send_keys(search_value)
            time.sleep(1)
            if search_type == "Name" or search_type == "":
                self.driver.find_element(By.XPATH, acc_listPage_object_searchName_posId).click()
            elif search_type == "UUID":
                self.driver.find_element(By.XPATH, listPage_objectSearch_select_UUID_posXpath).click()
            elif search_type == "Details":
                self.driver.find_element(By.XPATH, acc_listPage_object_searchDetails_posId).click()
            elif search_type == "Description":
                self.driver.find_element(By.XPATH, acc_listPage_object_searchDescription_posId).click()
            elif search_type == "Created By":
                self.driver.find_element(By.XPATH, acc_listPage_object_searchCreatedBy_posId).click()
        self.driver.implicitly_wait(3)
        time.sleep(1)
        self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()  # 点击搜索按钮
        time.sleep(0.5)
        self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()  # 再次点击搜索按钮

    def _query_verify(self, search_value, search_type, need_verify_vsysID=0):
        try:
            nodata_elem_isExist = self.driver.element_isExist(By.XPATH, acc_listPage_noDataText_posXpath)
            # print(nodata_elem_isExist)
            assert nodata_elem_isExist == False, "搜索失败，未搜索到数据！！"
        except Exception as e:
            print(e)
            raise
        self.second_elems_table = self.objects_po.extract_ele()  # 获取列表页第一列信息
        # assert self.first_elems_table["ID"] == self.second_elems_table["ID"], "校验失败！！创建的Object ID={}，当前页面的Object ID={}".format(self.first_elems_table["ID"],self.second_elems_table["ID"])
        if search_type == "Details":
            details_first_value = self.driver.find_element(By.XPATH,
                                                           acc_listPage_object_tableDetails_detailsRow_firstDetailValue_posXpaths).text
            assert search_value in details_first_value, "校验失败，搜索内容为{}，页面对应内容为{}".format(search_value,
                                                                                                        details_first_value)
            print("校验成功，搜索内容为{}，页面对应内容为{}".format(search_value, details_first_value))
        elif search_type == "Created By":
            pass
        else:
            assert search_value in self.objects_po.table_dict[
                search_type], "校验失败，搜索内容为{}，页面对应内容为{}".format(search_value,self.objects_po.table_dict[search_type])
            print(
                "校验成功，搜索内容为{}，页面对应内容为{}".format(search_value, self.objects_po.table_dict[search_type]))
        if need_verify_vsysID == 1:  # 校验vsysID
            pass

    @screenshot_on_failure
    def _modify(self, data):
        if data["Model"].strip().lower() == "create":  # 如果是create参数用例,则不用执行修改方法
            return 0
        else:
            # 勾选第一行元素
            self.first_row_checkBox_element = self.driver.find_element(By.XPATH,
                                                                       listPage_select_first_object_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
            # 解析修改数据
            self._operate_page(data, operation_type="edit", no_modify=False)
            # 进入Object详情页
            # 点击ok
            self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
            # if self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).is_displayed():
            #     self.driver.find_element(By.XPATH,acc_ObjectDetailPage_okButton_yes_posXpath).click()  # 点击确认弹窗的“Yes”按钮

    @screenshot_on_failure
    def _del(self, data, search_value=None, del_flag=None):
        """
        删除对象函数
        :param data: 主要为获取筛选方式和筛选值
        :param search_value: 如search_value不为空则不从data中获取search_value
        :param del_flag:1-简单用给定的search_value和Search Type=“Name“进行筛选。其他-从data中获取方式，从data中获取search_value或使用给定的search_value
        :return:
        """
        del_count = 10  # 定义最大删除条数
        if del_flag:
            self._simple_query_4_nest(search_value)
        else:
            search_type = data["Search type"]
            self._query(data, search_type=search_type, search_value=search_value)

        # 第一行可删除元素
        self.driver.implicitly_wait(5)
        if self.driver.element_isExist(By.XPATH,
                                       listPage_object_tableCheckbox_localVsysAndReferenceEqualO_objectOrGroup_posXpaths) == True:
            first_row_checkBox_element = self.driver.find_element(By.XPATH,
                                                                  listPage_object_tableCheckbox_localVsysAndReferenceEqualO_objectOrGroup_posXpaths)
            # 勾选第一行元素
            first_row_checkBox_element.click()
            # 调用objects的功能删除方法
            self.objects_po.delete(acc_listPage_deleteButton_posXpath,
                                   acc_listPage_object_delete_yesButton_posXpath,
                                   acc_listPage_object_urls_delete_noButton_posXpath)
            # 删除object group对象后，再删除子object对象
            while del_count > 0:
                self.go_to_page()
                print("del 循环")
                try:
                    if del_flag:
                        print("search_value111111111111111:{}".format(search_value))
                        self._simple_query_4_nest(search_value=search_value)

                    else:
                        print("search_value222222222222222:{}".format(search_value))
                        self._simple_query(data, search_value=search_value)
                    self.driver.implicitly_wait(5)
                    # self.driver.isElementExist(Element=acc_listPage_noDataText_posXpath)
                    self.driver.isElementExist(
                        Element=listPage_object_tableCheckbox_localVsysAndReferenceEqualO_objectOrGroup_posXpaths)
                    exist_data_elem = self.driver.Exist
                    print("No Data {}".format(exist_data_elem))
                    if exist_data_elem:
                        # 第一行元素
                        first_row_checkBox_element = self.driver.find_element(By.XPATH,listPage_object_tableCheckbox_localVsysAndReferenceEqualO_objectOrGroup_posXpaths)
                        first_row_checkBox_element.click()
                        self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()  # 点击删除按钮
                        self.driver.find_element(By.XPATH,acc_listPage_object_delete_yesButton_posXpath).click()  # 直接删除
                    else:
                        break
                except:
                    # time.sleep(0.5)
                    break
                finally:
                    del_count -= 1
        else:
            pass

    @screenshot_on_failure
    def _create_mutiLayer_nested_accGroup(self, data: {}):
        """
        #创建嵌套对象组
        :param data:
        :return:
        """
        # 跳转至acc页面
        self._goto_accountsPage()
        self._create_single_object(data)
        for i in range(len(data["Name"]) - 1):
            self._create_object_group(data, name=data["Name"][i + 1])
        # jksanfdjksannajdsn

    @screenshot_on_failure
    def _create_single_object(self, data: {}, name=None):
        # 点击create
        time.sleep(1)
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        type_elem0 = acc_listPage_createButton_account_posId  # Create下的acc选项
        self.driver.find_element(By.XPATH, type_elem0).click()  # 点击Create下的acc选项
        self._operate_name(data, no_modify=False)  # 于Name输入框键入上述随机Name
        # 添加acc item
        value = self._get_value_from_data(data, key="Items", data_index=0)
        self._items_acc_add(item_value=value)
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_description_posXpath).send_keys(
            "This is Description for {}".format(self.my_item_name))  # 键入Description
        # 点击OK
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
        # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).click()  # 点击确认弹窗的“Yes”按钮

    @screenshot_on_failure
    def _create_object_group(self, data: {}, name=None):
        time.sleep(1)
        # self.driver.find_element(By.XPATH, mainPage_secondLevelMenu_Account_posXpath).click()  # 跳转至acc页面
        self.driver.find_element(By.XPATH,"//div[@class='MuiListItem-root MuiListItem-gutters Mui-selected menu-account-object css-1l56wwh']").click()
        time.sleep(1)
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        type_elem1 = acc_listPage_createButton_accountGroup_posId  # Create下的Acc Group选项
        self.driver.find_element(By.XPATH, type_elem1).click()  # 点击Create下的Acc Group选项
        # Create ACC Group页面
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_nameInput_posXpath).send_keys(name)  # 于Name输入框键入上述随机Name
        ##过渡方案！！
        self.driver.find_element(By.XPATH,acc_ObjectGroupDetailPage_subObjects_addButton_newAdd_posXpath).click()  # 点击Subordinate Objects + 按钮
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_firstAccObject).click()  # 选择第一个ACC Object
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_cancel_posXpath).click() #点击cancel取消侧滑
        # 点击OK
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
        # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).click()  # 点击确认弹窗的“Yes”按钮

    def _get_value_from_data(self, data: {}, key="", data_index=0):
        """
        从data数据中，根据key提取值
        :param data:
        :param key:
        :param data_index: 0 -1
        :return:
        """

        try:
            if type(data[key]) == str:
                data_value: str = data[key].split("->")[data_index].strip()  # 用例数据
                # data_value_list = ['不修改']
                # print(data_value)
            elif type(data[key]) == list:
                data_value_list = []
                for i in data[key]:
                    i = i.split("->")[data_index].strip()
                    data_value_list.append(i)
                    data_value = data_value_list[0]
            #     # data_value = '不修改'
            #     # print(data_value_list)
        except Exception as e:
            print(e)
        return data_value

    @screenshot_on_failure
    def _del_quoted_objects(self, data):
        """
        对被引用对象执行删除操作，并断言
        :param data:
        :return:
        """
        self._create(data)  # 新建
        self._query(data)  # 创建后查询
        # 勾选被引用的对象
        first_quoted_object_elem_posXpath = listpage_select_second_object_posXpath  # 引用数大于0的第一个对象对应的勾选框元素Xpath
        first_quoted_object_elem = self.driver.find_element(By.XPATH,
                                                            first_quoted_object_elem_posXpath)  # 引用数大于0的第一个对象对应的勾选框元素
        first_quoted_object_elem.click()  # 点击勾选框
        # 定位删除按钮元素，并判断是否可点击
        del_button_elem_clickable = self.objects_po.is_element_clickable(listpage_delete_button_posXpath, "XPATH")
        print("当前元素是否可点击：{}".format(del_button_elem_clickable))
        assert del_button_elem_clickable == False, "校验删除按钮不可点击"

    @screenshot_on_failure
    def _reference_count(self):
        max_page = 10  # z最大翻页次数
        # Object 页面
        self._just_goto_accountsPage()  # 页面跳转
        current_page_reference_count_list = []
        try:
            reference_count_elems_posXpath = '//div[contains(@id,"-_Objects_account_Home_App_anonymousComponent")]'
            reference_count_elems_list = self.driver.find_elements(By.XPATH, reference_count_elems_posXpath)
            for i in reference_count_elems_list:
                current_page_reference_count_list.append(i.text)
            # print(list(set(current_page_reference_count_list)))
            current_page_reference_count_list = sorted(list(set(current_page_reference_count_list)))
            # print(current_page_reference_count_list)
            count = current_page_reference_count_list[-1]
            while int(count) == 0:  # 当正页的reference_count皆为0时，则往后翻页，直至找到不为0的
                max_page -= 1
                print("current max_page={}".format(max_page))
                # 后一页按钮
                nextPage_button = self.driver.find_element(By.XPATH, listPage_object_pages_nextPage_button_poxXpath)
                nextPage_button.click()
                # 重新获取count
                reference_count_elems_list = self.driver.find_elements(By.XPATH, reference_count_elems_posXpath)
                for i in reference_count_elems_list:
                    current_page_reference_count_list.append(i.text)
                # print(list(set(current_page_reference_count_list)))
                current_page_reference_count_list = sorted(list(set(current_page_reference_count_list)))
                # print(current_page_reference_count_list)
                count = current_page_reference_count_list[-1]
                if max_page == 0:  # 翻页次数用完跳出
                    break
        except:
            # count = random.randint(0, 3)  # 随机count
            count = 0
        # print(count)
        reference_count_elem_posXpath = '(//div[contains(@id,"-_Objects_account_Home_App_anonymousComponent") and text()={}])[1]'.format(
            count)
        # 点击reference count并校验
        self.driver.find_element(By.XPATH, reference_count_elem_posXpath).click()  # 点击reference count，弹出侧滑页面
        # 获取侧滑页面中引用策略等数目
        # usage_policies_elems_posXpath = '//div[@class="box-content"]'
        # usage_policies_elems_posXpath = '//div[@class="box-content"]/div'
        # usage_policies_elems_posXpath = '//div[@class="box-content"]//div[contains(@class,"showNamePointer")]'
        usage_policies_elems = self.driver.find_elements(By.XPATH,
                                                         listPage_referenceCount_drawerList_ruleOrObject_posXpaths)
        usage_count = len(usage_policies_elems)
        # print(usage_count, count)
        assert int(usage_count) == int(count), "reference count数目不匹配！！！{}--{}".format(usage_count, count)

    @screenshot_on_failure
    def _reference_by_object(self, data):
        """
        适用于可以创建Group 的Object
        :param data:
        :return:
        """
        try:
            # vsys0中创建 Object
            self.profile_pub.change_vsys(vsys_name="vsys0")  # 切换Vsys至Vsys0
            # self._just_goto_accountsPage()  # 跳转至对象创建页面
            self.create(data)  # vsys0中创建 Object
            # Vsys2中引用该Object并验证Reference Count
            self.profile_pub.change_vsys(vsys_name="UIAutoTestVsys")  # 切换Vsys至UI Vsys
            self._just_goto_accountsPage()  # 跳转至对象创建页面
            self._create_type(data={"Type": 1})  # 选择创建模式= group
            self._operate_name(data, no_modify=False)
            self._add_sub_objects_by_search()
            self._object_detail_page_save()  # 页面详情保存操作
            self._just_goto_accountsPage()  # 跳转至对象创建页面
            self._simple_query(data, search_value=self.my_item_name)
            # 验证Reference Count
            self.verify_obj_reference_count(button_disabled=False)
            # Vsys3中查看该Object并验证Reference Count
            self.profile_pub.change_vsys(vsys_name="PerformanceTestVsys")  # 切换Vsys至PerformanceTestVsys
            self._just_goto_accountsPage()  # 跳转至对象创建页面
            self._simple_query(data, search_value=self.my_item_name)
            # 验证Reference Count
            self.verify_obj_reference_count(button_disabled=True)
        finally:
            self.profile_pub.change_vsys(vsys_name="UIAutoTestVsys")  # 切换Vsys至UI Vsys
            self._just_goto_accountsPage()  # 跳转至对象创建页面
            self.delete(data, search_value=self.my_item_name, del_flag=1)
            self.profile_pub.change_vsys(vsys_name="vsys0")  # 切换Vsys至Vsys0
            self._just_goto_accountsPage()  # 跳转至对象创建页面
            self.delete(data, search_value=self.my_item_name, del_flag=1)

    def verify_obj_reference_count(self, button_disabled):
        reference_count_elem_posXpath = '(//div[contains(@class,"obj-charts-btn") and text()>0])[last()]'
        count = self.driver.find_element(By.XPATH, reference_count_elem_posXpath).text
        # 点击reference count
        self.driver.find_element(By.XPATH, reference_count_elem_posXpath).click()  # 点击reference count，弹出侧滑页面
        # 校验reference count
        usage_policies_elems = self.driver.find_elements(By.XPATH,
                                                         listPage_referenceCount_drawerList_ruleOrObject_posXpaths)
        usage_count = len(usage_policies_elems)
        # print(usage_count, count)
        assert int(usage_count) == int(count), "reference count数目不匹配！！！{}--{}".format(usage_count, count)
        edit_button_pos = '//button[@id="objectEdit_slider" and @disabled="disabled"]'

        if button_disabled:  # 引用条目不可点击，Edit按钮不可点击
            # 校验权限
            is_item_disabled = self.driver.element_isExist(By.XPATH,
                                                           listPage_referenceCount_drawerList_disabledRuleOrObject_posXpaths)
            is_button_disabled = self.driver.element_isExist(By.XPATH, edit_button_pos)
            assert is_button_disabled == button_disabled == is_item_disabled, "校验失败！Edit按钮是否可点击预期为{}，实际为{}".format(
                button_disabled, is_button_disabled)
        else:
            # 校验权限
            self.driver.find_element(By.XPATH,
                                     listPage_referenceCount_drawerList_ruleOrObject_posXpaths_template.format(
                                         1)).click()  # 点击第一个引用项目
            is_button_disabled = self.driver.element_isExist(By.XPATH, edit_button_pos)
            assert is_button_disabled == button_disabled, "校验失败！Edit按钮是否可点击预期为{}，实际为{}".format(
                button_disabled, is_button_disabled)
            # 验证页面跳转
            self.driver.find_element(By.XPATH, '//button[@id="objectEdit_slider"]').click()  # 点击EditButton，跳转至引用对象详情页
            is_page_right = self.driver.element_isExist(By.XPATH, '//div[@class="panel-header"]')
            assert is_page_right, "校验失败！页面未成功开启！！"

    def find_target_object(self, reference_type, data):
        # Object 页面
        self._just_goto_accountsPage()  # 页面跳转
        try:
            current_page_reference_count_list = self.get_current_page_reference_count_list(reference_type)
            # print(current_page_reference_count_list)
            if current_page_reference_count_list[-1] == 0:  # 全为0的话则新建Object Group
                self.create(data)
                current_page_reference_count_list = self.get_current_page_reference_count_list(reference_type)
                count = current_page_reference_count_list[-1]
            else:
                count = random.choice(current_page_reference_count_list)
        except:
            # count = random.randint(0, 3)  # 随机count
            count = 0
        # print(count)
        reference_count_elem_posXpath = '(//div[contains(@id,"-_Objects_account_Home_App_anonymousComponent") and text()={}])[1]'.format(
            count)
        return count, reference_count_elem_posXpath

    def get_current_page_reference_count_list(self, reference_type):
        # 获取当前页面中的Reference Count List
        current_page_reference_count_list = []
        if reference_type == 0:  # 本Vsys
            reference_count_elems_posXpath = listPage_localVsys_referenceCount_posXpaths
        else:  # 非本Vsys
            reference_count_elems_posXpath = listPage_notLocalVsys_referenceCount_posXpaths
        reference_count_elems_list = self.driver.find_elements(By.XPATH, reference_count_elems_posXpath)
        for i in reference_count_elems_list:
            current_page_reference_count_list.append(i.text)
        # print(list(set(current_page_reference_count_list)))
        current_page_reference_count_list = sorted(list(set(current_page_reference_count_list)))
        return current_page_reference_count_list

    @screenshot_on_failure
    def _operate_columns(self):
        self._goto_accountsPage()  # 页面跳转
        self.objects_po.Column_settings(Column=acc_object_columnSetting_descriptionOption_posXpath)
        self.objects_po.Column_ele_ex(Column_text=self.objects_po.Column_text)
        assert self.objects_po.result

    def export_multi_condition_test(self,data):
        self.create(data)  # 新建,新建后就是查询到该条数据的状态
        if data["SubType"] == "cancel_export":
            #1、单个Object导出取消选中目标数据
            self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
            self.pop_cancel_export_num()
            self.create(data)
            # 2、多个Object导出取消选中目标数据(2个)
            self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_select_second_object_posXpath).click()
            self.pop_cancel_export_num()
            self._del(data)
        elif data["SubType"] == "multi_export":
            if data["multi_type"] == "all":#4、多选导出所有数据，校验行数
                self.create(data)
                self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
                self.driver.find_element(By.XPATH, listpage_select_second_object_posXpath).click()
                self._export_objects1()
                assert self.export_number == 2,"断言多选全部导出是否符合预期"
                self._del(data)
            elif data["multi_type"] == "part":#3、多选导出第一个数据
                self.create(data)
                self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
                self.driver.find_element(By.XPATH, listpage_select_second_object_posXpath).click()
                self.pop_export_part()
                assert self.export_number == 1,"断言单选导出数据是否符合预期"
                time.sleep(2)
                self.driver.refresh()
                self._del(data)
            else:    #多选数据中有group时无法导出
                self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
                self.driver.find_element(By.XPATH, listpage_select_second_object_posXpath).click()
                #self.driver.find_element(By.XPATH,listPage_object_apns_exportButton_posXpath).click()
                status = self.driver.isElementExist(Element='//span[@class="action-export inline-flex mr-[8px] "]//button[contains(@class, "disabled")]')
                assert status == True
                # export_tip = self.driver.find_element(By.XPATH,'//div[@class="el-message el-message--error"]/p').text
                # assert export_tip.strip() == "Object group is not exportable"
                self._del(data)


    def pop_export_part(self):
        self.driver.find_element(By.XPATH, listpage_export_button_posXpath).click()
        self.driver.find_element(By.XPATH, '//div[@role="dialog"]//div[@data-rowindex="0"]//input').click()  # 选择第一个
        self.export_total_str = self.driver.find_element(By.XPATH,'//div[@class="text-center color-[--color-text] mt-[12px] MuiBox-root css-0"]').text  # 定位到导出个数的按钮
        self.export_total = re.search(r'\d+', self.export_total_str)  # 正则表达式返回匹配的数字对象
        if self.export_total:
            self.export_number = int(self.export_total.group())  # group()方法返回正则表达式匹配的字符串
            print(self.export_number)

    def pop_cancel_export_num(self):
        self.driver.find_element(By.XPATH, listpage_export_button_posXpath).click()
        self.driver.isElementExist(Element=port_listPage_object_exportPopYes_posXpath)
        assert self.driver.Exist, "断言导出按钮是否置灰不展示"
        self.driver.find_element(By.XPATH, listpage_export_no_button_posXpath).click()
        self.driver.refresh()

    def _export_objects1(self):
        self.driver.find_element(By.XPATH, listpage_export_button_posXpath).click()
        time.sleep(3)
        self.export_total_str = self.driver.find_element(By.XPATH,'//div[@class="text-center color-[--color-text] mt-[12px] MuiBox-root css-0"]').text
        self.driver.find_element(By.XPATH, listPage_object_urls_exportPopYes_posXpath).click()
        print(11111)
        self.export_total =re.search(r'\d+',self.export_total_str)  #正则表达式返回匹配的数字对象
        print(self.export_total_str)
        print(2222)
        print(self.export_total)
        if self.export_total:
            self.export_number = int(self.export_total.group())#group()方法返回正则表达式匹配的字符串
            print(self.export_number)

    @screenshot_on_failure
    def _export_objects_and_verify(self, data):
        self._create(data)  # 新建
        self._query(data)  # 创建后查询
        self._export_objects()  # 选中并导出文件
        # source_data = data["Items"][0]
        time.sleep(3)
        self.file_name = get_txt_filenames(path=self.my_files._obj_files_dowload_path())
        self.file_path = self.my_files._obj_files_dowload_path() + "\\" + self.file_name
        self.content = open(self.file_path, "rb").read()
        print("self.content :{}|||source_data:{}".format(self.content, self.random_account))
        try:
            # assert str(data['Items'][0]) in str(self.content), "断言导出内容是否在txt文件中"
            assert str(self.random_account) in str(
                self.content), "断言导出内容是否在txt文件中,此时源数据为{}，导出文件读取数据为{}".format(
                self.random_account, self.content)
            os.remove(self.file_path)
            print("文件删除成功")
        except:
            print("文件不存在")
            raise
        finally:
            # self._query(data)
            self._del(data)

    @screenshot_on_failure
    def _export_objects(self):
        """
        :return:
        """
        self.driver.implicitly_wait(5)
        self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
        self.driver.find_element(By.XPATH,
                                 acc_listPage_object_exportButton_posXpath).click()
        self.driver.find_element(By.XPATH, acc_listPage_object_exportPopYes_posXpath).click()

    @screenshot_on_failure
    def _add_to_watchList(self):
        # self._goto_subObjectsPage()
        # self.add_watch_list()
        self.objects_po.extract_ele()
        # 清空watch列表页
        self.driver.find_element(By.XPATH, listPage_objectSearch_mobileIdentities_right_list_watch_posXpath).click()
        self.driver.find_element(By.XPATH,
                                 listPage_objectSearch_mobileIdentities_right_list_watch_object_posXpath).click()
        self.driver.find_element(By.XPATH,
                                 listPage_objectSearch_mobileIdentities_right_list_watch_select_all_posXpath).click()
        self.driver.find_element(By.XPATH,
                                 listPage_objectSearch_mobileIdentities_right_list_watch_select_clear_posXpath).click()
        # 添加watch列表页
        self.driver.find_element(By.XPATH, listPage_object_mobileIdentities_select_First_object_posXpath).click()
        self.driver.find_element(By.XPATH, listPage_objectSearch_mobileIdentities_add_watch_posXpath).click()
        # 查看watch_list
        time.sleep(3)
        self.watch_ID = self.driver.find_element(By.XPATH, '//ul/li[1]/div/label/span[2]/p[1]').text
        self.watch_Name = self.driver.find_element(By.XPATH, '//ul/li[1]/div/label/span[2]/p[2]').text
        print(self.watch_ID, self.watch_Name)
        assert self.objects_po.table_dict["ID"] == self.watch_ID, "断言添加到watch列表中的ID是否正确"
        assert self.objects_po.table_dict["Name"] == self.watch_Name, "断言添加到watch列表中的Name是否正确"

    @screenshot_on_failure
    def old_verify_audit_logs(self, data):
        # 新建
        self._create(data)  # 新建
        self._query(data, need_verify_details=0)  # 创建后查询
        # 选中并进入编辑页面
        self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
        # 点击Audit Logs
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_auditLogs_posXpath).click()
        self.driver.find_element(By.XPATH,
                                 acc_ObjectDetailPage_auditLogsDrawer_firstRowLog_checkBox_posXpath).click()  # 勾选第一行log CheckBox
        self.driver.find_element(By.XPATH,
                                 acc_ObjectDetailPage_auditLogsDrawer_compareButton_posXpath).click()  # 点击compare 按钮
        try:
            operation = self.driver.find_element(By.XPATH,
                                                 acc_ObjectDetailPage_auditLogsDrawer_compareDrawer_operationText_posXpath).text
            assert operation == "Create", "最新一条audit log 非 Create log！！！！"
            print("校验成功，获取到 Create log")
        except Exception as e:
            print(e)
            raise
        # self.driver.isElementExist(Element='//div/div/div/div[2]/div[2]/div/div[2]/div[3]/table/tbody/tr')
        # assert self.driver.Exist, "断言新建object是否存在创建日志"
        # print("断言成功")

        # 修改
        self._query(data, need_verify_details=0)  # 查询
        self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
        # 解析修改数据
        self._operate_page(data, operation_type="edit")
        # 点击ok
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
        # if self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).is_displayed():
        #     self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).click()  # 点击确认弹窗的“Yes”按钮
        # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).click()  # 点击确认弹窗的“Yes”按钮
        # print("保存")
        # 重新进入对象详情页查看audit logs
        self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_auditLogs_posXpath).click()  # 点击Audit Logs
        self.driver.find_element(By.XPATH,
                                 acc_ObjectDetailPage_auditLogsDrawer_firstRowLog_checkBox_posXpath).click()  # 勾选第一行log CheckBox
        self.driver.find_element(By.XPATH,
                                 acc_ObjectDetailPage_auditLogsDrawer_compareButton_posXpath).click()  # 点击compare 按钮
        try:
            operation = self.driver.find_element(By.XPATH,
                                                 acc_ObjectDetailPage_auditLogsDrawer_compareDrawer_operationText_posXpath).text
            # orgin_value = self.driver.find_element(By.XPATH,
            #                                        '(//div[@class="code-comparecode"]//span[contains(text(),"keywords")])[1]').text
            # update_value = self.driver.find_element(By.XPATH,
            #                                         '(//div[@class="code-comparecode"]//span[contains(text(),"keywords")])[2]').text
            # print(update_value)
            assert operation == "Edit", "最新一条audit log 非 Edit log！！！！"
            print("校验成功，获取到 Edit log")
        except Exception as e:
            print(e)
            raise

        # 清除测试数据
        self.driver.find_element(By.XPATH, mainPage_secondLevelMenu_Account_posXpath).click()  # 返回acc列表页
        # self._query(data, need_verify_details=0)  # 查询
        self._del(data)

    @screenshot_on_failure
    def _verify_audit_logs(self, data):
        # 新建
        self._create(data)  # 新建
        try:
            self._query(data, need_verify_details=0)  # 创建后查询
            # 选中并进入编辑页面
            self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
            # 校验Audit Logs
            self.objects_po.audit_log_check("Account Object", "Create")
            # 修改
            self._query(data, need_verify_details=0)  # 查询
            self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
            # 解析修改数据
            self._operate_page(data, operation_type="edit")
            # 点击ok
            self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
            # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_okButton_yes_posXpath).click()  # 点击确认弹窗的“Yes”按钮
            # print("保存")
            # 重新进入对象详情页查看audit logs
            self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
            # 校验Audit Logs
            self.objects_po.audit_log_check("Account Object", "Edit")
        except Exception as e:
            raise e
        finally:
            # 清除测试数据
            self._del(data)

    @screenshot_on_failure
    def _verify_items_total(self, data):
        self._create(data)  # 新建
        self._query(data)  # 创建后查询
        self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()  # 勾选第一行元素
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
        # 进入编辑页面

        items_total = self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemsTotal_posXpath).text  # Total 值
        # print("items_total0:{}".format(items_total))
        # items_total = items_total.split(":")[1].strip()
        print("items_total:{}".format(items_total))
        try:
            if int(items_total) == 0:
                self.driver.implicitly_wait(5)
                time.sleep(2)
                items_total = self.driver.find_element(By.XPATH,acc_ObjectDetailPage_itemsTotal_posXpath).text  # Total 值
                # items_total = items_total.split(":")[1].strip()
                # print("items_total1:{}".format(items_total))
        except:
            pass
        finally:
            assert len(data["Items"]) == int(items_total), "校验失败，Total数值不正确，页面Total={}，数据源Total={}".format(int(items_total), len(data["Items"]))
            self.driver.find_element(By.XPATH, "//div[@class='MuiListItem-root MuiListItem-gutters Mui-selected menu-account-object css-1l56wwh']").click()  # 返回acc列表页
            # self._query(data)  # 查询
            self._del(data)

    @screenshot_on_failure
    def _verify_item_value_from_file(self, data):
        # 跳转至Categories创建页面
        self._goto_accountsPage()
        self.driver.implicitly_wait(5)
        # 点击create
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()
        # 选择Category
        self.driver.find_element(By.XPATH, acc_listPage_createButton_account_posId).click()
        # 页面选项操作
        self._operate_name(data, no_modify=None)
        # 添加acc item from file
        data_file_name = self._get_value_from_data(data, key="Items", data_index=0)[:-16]
        print(data_file_name)
        # 点击Import From File
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_importFromFile_posXpath).click()
        # 于Please Upload input 上传文件
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_pleaseUpload_posXpath).send_keys(self.my_files._obj_files_path(file_name=data_file_name))
        try:
            error_message = self.driver.find_element(By.XPATH, "(//div[@data-field='status'])[2]").text
            print(error_message)
            assert (error_message == "Incorrect match format"
                    or error_message == "Require at least 3 bytes for any single substring , the total length of string can not exceed 1024 bytes."
                    or error_message == "Duplicate")

        except Exception as e:
            print(e)

    @screenshot_on_failure
    def _verify_object_name_input(self, data):
        # 跳转至Acc创建页面
        self._goto_accountsPage()
        self.driver.implicitly_wait(5)
        # 点击create
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()
        # 选择Account
        self.driver.find_element(By.XPATH, acc_listPage_createButton_account_posId).click()
        # 页面选项操作
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_nameInput_posXpath).send_keys(data["Name"])  # 于Name输入框Name
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
        if len(data["Name"]) < 4:
            error_message = self.driver.find_element(By.XPATH, "//div[@class='account-object-name']/div[2]").text
            print(error_message)
            assert error_message == "The length of the name is at most 128 characters and cannot be less than 4 characters"
        else:  # 长度大于128
            # actually_name = self.driver.find_element(By.XPATH,acc_ObjectDetailPage_nameInput_posXpath)
            actually_name_lenth_number = self.driver.find_element(By.XPATH,acc_ObjectDetailPage_nameLenthNumber_posXpath).text
            # print(actually_name_lenth_number)
            assert actually_name_lenth_number == '128/128', "校验失败！actually_name_lenth_number ={}".format(
                actually_name_lenth_number)

    @screenshot_on_failure
    def _verify_item_value_input(self, data):
        # 跳转至Account创建页面
        self._goto_accountsPage()
        self.driver.implicitly_wait(5)
        # 点击create
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()
        # 选择Account
        self.driver.find_element(By.XPATH, acc_listPage_createButton_account_posId).click()
        # 页面选项操作
        self._operate_name(data, no_modify=None)  # 于Name输入框Name
        # # 点击OK
        self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮

        try:
            error_message_elem = "//div[@class='items']/div[2]"
            error_message = self.driver.find_element(By.XPATH, error_message_elem).text
            assert error_message == "Please add at least one item", "当前error_message={}!!".format(error_message)
            print("校验通过，页面提示且{}=Please add at least one item".format(error_message))
            if not self.driver.element_isExist(By.XPATH, error_message_elem):
                self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 点击“OK”按钮
                assert error_message == "Please add at least one item", "当前error_message={}!!".format(error_message)
                print("校验通过，页面提示且{}=Please add at least one item".format(error_message))
        except Exception as e:
            print(e)

    @screenshot_on_failure
    def _export_and_verify_checkbox(self, data):
        try:
            selected_object_type = data["selected_object_type"]  # data中选择类型：0-对象，1-对象组
            selected_objects_number = data["selected_objects"]  # data中选中对象数量
            selected_data_number = data["selected_data"]  # data中选中数据数量（点击导出后的Pop up 窗口）
            print(selected_object_type, selected_objects_number, selected_data_number)
            obj_data = {"Model": "create",
                        "Type": 1,
                        "Name": "test_ui 4 checkbox & export",
                        "Items": [],
                        "Description": "",
                        "Subordinate Objects": {
                            "subName": "",
                            "subItems": [
                                "[random]->"
                            ],
                            "subDescription": ""
                        }, }
            self._create(data=obj_data)
            self._just_goto_accountsPage()  # 跳转至acc列表页
            self.driver.implicitly_wait(5)
            self._operate_checkbox(selected_object_type, selected_objects_number)  # 列表页选择操作
            object_details_values = self._get_objects_details_from_listPage()
            # 下载前判断download文件夹是否为空
            self.objects_po.delete_folder_contents(self.my_files._obj_files_dowload_path())
            no_need_to_verify = self._export_objects_secondSelect(selected_data_number,
                                                                  selected_object_type)  # 导出，导出页面选择操作，确定导出
            if object_details_values is not None:
                object_details_values = object_details_values[:int(selected_data_number)]
            else:
                object_details_values = object_details_values
            # print(no_need_to_verify)
            self._verify_checkbox(object_details_values, selected_data_number, no_need_to_verify=no_need_to_verify)  #

            # self._query(data=data, search_value="test_ui", need_verify_details=0)
            # self._simple_query(data=data, search_value="test_ui", need_verify_details=0)
        except Exception as e:
            raise e
        finally:
            self._del(data, search_value=self.my_item_name)

    @screenshot_on_failure
    def _operate_checkbox(self, selected_object_type, selected_objects_number):
        """

        :param selected_object_type: 选中类型（0-对象，1-对象组）   上层调用传入
        :param selected_objects_number: 选中对象/对象组    数目上层调用传入
        :return:

        # 单选并导出操作1
        # 单选对象，但取消选择全部数据1
        # 单选对象组并导出-错误提示1
        # 多选并导出操作1
        # 多选对象但单选数据1
        # 多选对象，但取消选择全部数据1
        # 多选对象，但取消选择部分数据1
        # 多选对象组并导出-错误提示1
        # 多选对象与对象组并导出-错误提示
        # 未选择对象，导出（验证怎么验）1
        """
        print("This is _operate_checkbox")

        selected_objects_number = selected_objects_number + 1  # 为解决find_elements获取元素少一个的问题，过渡方案！！！！！此时单元为选两个！！！
        # 选择模式
        if selected_object_type == 0:  # data中选择类型：0-对象，1-对象组，2-对象与对象组
            self.no_need_to_get_data_from_list_page = 0  # 需要在列表页获取对象details value
            object_checkbox_elems = self.driver.find_elements(By.XPATH,acc_listPage_object_tableCheckbox_singleObject_posXpaths)  # 定位所有single object对应的CheckBox
            print("object_checkbox_elems{}".format(object_checkbox_elems))

            if selected_objects_number == 0:  # 不选中对象
                self.no_need_to_get_data_from_list_page = 2  # 需要在列表页获取对象details value，且目标为所有对象
            else:  # 选中头selected_objects 个对象
                for i in object_checkbox_elems:
                    if selected_objects_number < 1:
                        break
                    else:
                        i.click()
                        selected_objects_number -= 1
        elif selected_object_type == 1:  # data中选择类型：0-对象，1-对象组
            self.no_need_to_get_data_from_list_page = 1  # 不需要在列表页获取对象details value
            # 定位对象组
            object_group_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                    acc_listPage_object_tableCheckbox_objectGroup_posXpaths)
            print("object_group_checkbox_elems{}".format(object_group_checkbox_elems))
            # 选中头selected_objects 个对象
            for i in object_group_checkbox_elems:
                if selected_objects_number < 1:
                    break
                else:
                    i.click()
                    selected_objects_number -= 1
        elif selected_object_type == 2:  # 2 选中对象与对象组
            print("selected_object_type== 2")
            self.no_need_to_get_data_from_list_page = 1  # 不需要在列表页获取对象details value
            # 定位所有single object对应的CheckBox
            object_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                              acc_listPage_object_tableCheckbox_singleObject_posXpaths)
            # 页面中所有对象、对象组的CheckBox
            object_group_and_single_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                               acc_listPage_object_tableCheckbox_posXpaths)
            # 定位对象组
            object_group_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                    acc_listPage_object_tableCheckbox_objectGroup_posXpaths)
            for i in object_group_checkbox_elems:
                if selected_objects_number == 1:  # 剩余一个，用于勾选单独对象
                    break
                else:
                    i.click()
                    print("i.click()")
                    selected_objects_number -= 1
            for j in object_checkbox_elems:
                if selected_objects_number < 1:
                    break
                else:
                    j.click()
                    print("j.click()")
                    selected_objects_number -= 1

        print("This is _operate_checkbox end")

    @screenshot_on_failure
    def _get_objects_details_from_listPage(self):
        if self.no_need_to_get_data_from_list_page == 1:  # 不需要执行操作，pass #0-2获取数据，1-不需获取数据
            pass
        else:
            if self.no_need_to_get_data_from_list_page == 2:  # 当前页面所有对象（不包含对象组）
                list_object_details_elems = self.driver.find_elements(By.XPATH,
                                                                      acc_listPage_object_tableDetails_singleObject_posXpaths)
                print("allLLlllist_object_details_elems:{}".format(list_object_details_elems))
            else:  # self.no_need_to_get_data_from_list_page == 0
                self.driver.implicitly_wait(5)
                time.sleep(10)
                list_object_details_elems = self.driver.find_elements(By.XPATH,
                                                                      acc_listPage_object_tableDetails_selected_detailsRow_posXpaths)  # details元素列表
                print("list_object_details_elems:{}".format(list_object_details_elems))
                # assert len(list_object_details_elems) >= 1, "校验 list_object_details_elems"
            object_details_values = []
            for i in list_object_details_elems:
                print(i)
                time.sleep(1)
                i.click()
                print("点击操作{}".format(i))
                object_details_elems = self.driver.find_elements(By.XPATH,
                                                                 acc_listPage_object_tableDetails_firstRowValues_div_posXpaths)
                print("object_details_elems:{}".format(object_details_elems))
                # object_details_close_button = self.driver.find_element(By.XPATH,
                #                                                        '//li[@class="row el-dropdown-menu__item"]//div[@class="row-content-cell"]/ancestor::div[@class="CommonItems list-box"]//div[@class="rigth-menu-button-info"]/button')  # Details 侧滑页面Close按钮
                object_details_close_button = self.driver.find_element(By.XPATH,
                                                                       '//*[@class="LocalationDraswer lstsub policy-right-show-edit v-draswer"]//*[@class="el-button right-menu-button-close el-button--info el-button--small"]')  # Details 侧滑页面Close按钮
                object_details_close_button.click()
                for j in object_details_elems:
                    object_details_values.append(j.text)
            print("object_details_values:{}".format(object_details_values))
            return object_details_values

    @screenshot_on_failure
    def _export_objects_secondSelect(self, selected_data_number, selected_object_type):
        no_need_to_verify = 0  # 是否需要后续校验文件flag
        self.driver.find_element(By.XPATH, acc_listPage_object_exportButton_posXpath).click()  # 点击导出按钮

        calcu_selected_data_number = selected_data_number
        if selected_object_type == 0:  # 导出单独的对象

            self.driver.find_element(By.XPATH,acc_listPage_object_exportPopSelectAll_posXpath).click()  # 点击全选按钮，取消默认全选
            if selected_data_number > 0:
                data_checkbox_elems = self.driver.find_elements(By.XPATH,acc_listPage_object_exportPopCheckbox_posXpaths)  # 导出弹窗数据CheckBox

                # 选择头selected_data_number个数据
                for i in data_checkbox_elems:
                    if calcu_selected_data_number < 1:
                        break
                    else:
                        i.click()
                        calcu_selected_data_number -= 1
                self.driver.find_element(By.XPATH, acc_listPage_object_exportPopYes_posXpath).click()  # 点击Yes
            # elif selected_data_number == 0:
            #     self.driver.find_element(By.XPATH, acc_listPage_object_exportPopYes_posXpath).click()  # 点击Yes
            else:

                self.driver.isElementExist(Element=acc_listPage_object_exportPopYes_posXpath)
                assert self.driver.Exist, "定位Yes按钮不可点击"
                print("断言成功，该元素无法点击")
                no_need_to_verify = 1
                self.driver.refresh()
        else:  # 执行导出对象组或对象与对象组操作
            no_need_to_verify = 1
            # 24.02版本方式
            self.driver.find_element(By.XPATH, acc_listPage_object_exportPopYes_posXpath).click()  # 点击Yes
            alert_message_elem_Xpath = '//div[@role="alert"]'
            alert_message_elem = self.driver.find_element(By.XPATH, alert_message_elem_Xpath)
            print(alert_message_elem.text)
            expected_text = 'Object group is not exportable'
            assert expected_text in alert_message_elem.text, "alert message is {}".format(alert_message_elem.text)
            self.driver.find_element(By.XPATH, acc_listPage_object_exportPopNo_posXpath).click()  # 点击 No

        return no_need_to_verify

    def _verify_checkbox(self, object_details_values, selected_data_number, no_need_to_verify=0):
        """
        未完成
        :param data:
        :return:
        """
        if no_need_to_verify != 1:  # 需要校验文件
            # time.sleep(5)  # 等待识别文件
            try:
                self.file_name = get_txt_filenames(path=self.my_files._obj_files_dowload_path())
                # assert 1==2
            except Exception as e:
                # print("捕获到错误:", e)
                start_time = time.time()
                deadline_time = start_time + 10
                while True:
                    try:
                        self.file_name = get_txt_filenames(path=self.my_files._obj_files_dowload_path())
                    except:
                        self.file_name = False
                    # if (time.time()-start_time)%1==0:
                    #     print(f"等待了{time.time()-start_time}s")
                    if self.file_name:
                        # print(f"等待了{time.time()-start_time}s")
                        # print("已读取到FileName={}".format(self.file_name))
                        break
                    if time.time() > deadline_time:
                        # print("到达等待截止时间，current_tinme={},deadline={}".format(time.time(),deadline_time))
                        break
            print("self.file_name:{}".format(self.file_name))
            self.file_path = self.my_files._obj_files_dowload_path() + "\\" + self.file_name
            print("self.file_path:{}".format(self.file_path))
            self.content = open(self.file_path, "rb").read()
            print("self.content :{}|||object_details_values:{}".format(self.content, object_details_values))
            try:
                # assert str(data['Items'][0]) in str(self.content), "断言导出内容是否在txt文件中"
                for i in object_details_values:
                    assert str(i) in str(self.content), "导出内容不在txt文件中！！页面内容：{}-文件内容：{}".format(str(i),
                                                                                                                str(self.content))
                    selected_data_number -= 1
                    if selected_data_number < 1:
                        break
                os.remove(self.file_path)
                print("文件删除成功")
            except Exception as e:
                # print("文件不存在")
                print(e)
                raise
        else:  # 不需要校验文件
            pass

    @screenshot_on_failure
    def _switch_page_after_selected(self, data):
        selected_object_type = data["selected_object_type"]
        selected_objects_number = data["selected_objects"]
        operations_after_selected = data["operations_after_selected"]
        # 进入acc列表页
        self._goto_accountsPage()
        # 选择对象
        self.driver.implicitly_wait(5)
        self._operate_checkbox(selected_object_type, selected_objects_number)
        # time.sleep(3)
        # 后续操作
        self._operations_after_selected(operations_after_selected)
        # 返回列表页
        # time.sleep(3)
        # 校验是否还被选中
        self._verify_is_selected()

    @screenshot_on_failure
    def _operations_after_selected(self, operations_after_selected):
        # operations_after_selected=0 翻页操作，1 创建操作，2 导入操作
        if operations_after_selected == 0:  # 执行翻页操作
            # print("执行翻页操作")
            try:
                self.objects_po.pages_turning(data={"turn_mode": 1, "destination_page": "2"})
                # print("self.objects_po.turn_page_falg={}".format(self.objects_po.turn_page_falg))
                if self.objects_po.turn_page_falg == 0:
                    raise Exception("页码仅为1页，无法进行翻页操作！")
                else:
                    # self.objects_po.pages_turning(data={"turn_mode": 1, "destination_page": "2"})  # 直接跳转至对应页面(第二页)
                    # time.sleep(1)
                    # 返回列表页
                    self.objects_po.pages_turning(data={"turn_mode": 1, "destination_page": "1"})  # 直接跳转至对应页面(第二页)
                    time.sleep(1)
            except Exception as e:
                print(e)
        elif operations_after_selected == 1:  # 执行创建操作
            self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
            type_elem0 = acc_listPage_createButton_account_posId  # Create下的acc选项
            self.driver.find_element(By.XPATH, type_elem0).click()  # 点击Create下的acc选项
            time.sleep(1)
            # 返回列表页
            self.driver.back()
            time.sleep(1)
        else:  # 导入操作
            pass

    def _verify_is_selected(self):
        try:
            self.driver.isElementExist(
                acc_listPage_object_tableCheckbox_selectedCheckBox_posXpaths)  ##list页被选中的对象 CheckBox Xpath
            assert self.driver.Exist == False, "校验失败！！存在被选中对象！！"
            # print("校验成功")
        except Exception as e:
            # print("校验失败")
            print(e)
            raise

    @screenshot_on_failure
    def _importFromFile_whenItemEditing(self, data):
        # 创建对象
        self._create(data)
        # 编辑对象，并编辑item
        self._query(data, need_verify_details=0)  # 搜索
        self.first_row_checkBox_element = self.driver.find_element(By.XPATH,listPage_select_first_object_posXpath).click()  # 勾选第一行元素
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮

        item_data = data["Items"][0]
        if item_data == "[random]":
            item_data = self.random_account
        acc_item_edit_btn_xpath = "(//*[normalize-space(text())='{acc}']/ancestor::*[@class='css-103las5']//i[contains(@class, 'iconfont icon-Edit')])[1]".format(acc=item_data)
        self.driver.find_element(By.XPATH, acc_item_edit_btn_xpath).click()  # 点击要修改数据的编辑按钮操作
        # 校验此时ImportFromFile按钮不可点击
        try:
            try:
                is_disabled = self.driver.find_element(By.XPATH,acc_ObjectDetailPage_importFromFile_button_posXpath).get_attribute("disabled")
                print("is_disabled:{}".format(is_disabled))
                assert is_disabled == 'true', "校验失败！此时按钮可点击"
                print("校验成功，按钮不可点击")
            except Exception as e:
                print(e)
                raise
        finally:
            # 清除测试数据
            # self._query(data, need_verify_details=0)  # 搜索
            self._del(data)  # 删除

    @screenshot_on_failure
    def _addItem_before_uploadFileDeleted(self, data):

        # 跳转至acc页面
        self._goto_accountsPage()
        # 创建对象
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        type_elem0 = acc_listPage_createButton_account_posId  # Create下的acc选项
        self.driver.find_element(By.XPATH, type_elem0).click()  # 点击Create下的acc选项
        # 文件导入item
        self._items_acc_add_from_file(data_file_name=data["Items"][0][:-16])

        time.sleep(1)
        ###校验此时add item "+"按钮是否可点击
        try:
            self.driver.find_element(By.XPATH, acc_ObjectDetailPage_item_addButton_poXpath).click()
        except Exception as e:
            print(e)
            assert "is not clickable at point " in str(e), "此时按钮可点击"

        # 删除文件
        file_elem = self.driver.find_element(By.XPATH,
                                             acc_ObjectDetailPage_importedFile_posXpath)  # 文件元素位置
        ActionChains(self.driver).move_to_element(file_elem).perform()  # 鼠标悬停操作
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_importedFile_delete_posXpath).click()  # 点击文件删除按钮
        # 再次点击add item "+"按钮
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_item_addButton_poXpath).click()
        try:
            self.driver.isElementExist(acc_ObjectDetailPage_itemSaveButton_poXpath)
            is_exist = self.driver.Exist
            print(is_exist)
            assert is_exist == True, "此时item 保存按钮不存在"
            print("校验成功，此时item 保存按钮存在")
        except Exception as e:
            print(e)
            raise

    def _itemFile_downloadAndDelete(self, data):
        # 跳转至acc页面
        self._goto_accountsPage()
        # 创建对象
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        type_elem0 = acc_listPage_createButton_account_posId  # Create下的acc选项
        self.driver.find_element(By.XPATH, type_elem0).click()  # 点击Create下的acc选项
        # 文件导入item
        self._items_acc_add_from_file(data_file_name=data["Items"][0][:-16])
        time.sleep(1)

        ####下载校验
        ##读取导入源件内容
        with open(self.my_files._obj_files_path(file_name=data["Items"][0][:-16]), "r", encoding="utf-8") as f:
            source_content = f.read()
            print(source_content)

        # 下载前判断download文件夹是否为空
        self.objects_po.delete_folder_contents(self.my_files._obj_files_dowload_path())

        # 下载操作
        file_elem = self.driver.find_element(By.XPATH,
                                             acc_ObjectDetailPage_importedFile_posXpath)  # 文件元素位置
        ActionChains(self.driver).move_to_element(file_elem).perform()  # 鼠标悬停操作
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_importedFile_download_posXpath).click()  # 点击文件下载按钮
        time.sleep(3)
        # 校验成功下载
        self.file_name = get_txt_filenames(path=self.my_files._obj_files_dowload_path())
        self.file_path = self.my_files._obj_files_dowload_path() + "\\" + self.file_name
        # self.content = open(self.file_path, "rb").read()
        self.content = open(self.file_path, "r", encoding='utf-8').read()
        print("self.random_acc:{}|||self.content :{}".format(source_content, self.content))
        try:

            assert str(source_content) in str(self.content), "断言失败！！source_content为{}，content为{}".format(
                str(source_content), str(self.content))
            os.remove(self.file_path)
            print("文件删除成功")
        except Exception as e:
            print(e)
            raise

        # 跳转至acc页面
        self._goto_accountsPage()
        # 创建对象
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        type_elem0 = acc_listPage_createButton_account_posId  # Create下的acc选项
        self.driver.find_element(By.XPATH, type_elem0).click()  # 点击Create下的acc选项
        # 文件导入item
        self._items_acc_add_from_file(data_file_name=data["Items"][0][:-16])
        time.sleep(1)

        ####删除校验

        # 删除操作
        file_elem = self.driver.find_element(By.XPATH,
                                             acc_ObjectDetailPage_importedFile_posXpath)  # 文件元素位置
        ActionChains(self.driver).move_to_element(file_elem).perform()  # 鼠标悬停操作
        self.driver.find_element(By.XPATH, acc_ObjectDetailPage_importedFile_delete_posXpath).click()  # 点击文件删除按钮
        # 校验是否删除成功
        try:
            self.driver.isElementExist(acc_ObjectDetailPage_importedFile_posXpath)
            print(self.driver.Exist)
            assert self.driver.Exist == False, '此时文件存在，文件删除失败'
            print("校验成功，文件删除成功")
        except Exception as e:
            print(e)
            raise

    @screenshot_on_failure
    def _groupAddIncludeAndExcludeItem(self, data):
        pass  # todo

    @screenshot_on_failure
    def _only_exclude_item(self, data):
        # 跳转至acc页面
        self._goto_accountsPage()
        # 创建对象组
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        type_elem1 = acc_listPage_createButton_accountGroup_posId  # Create下的acc Group选项
        self.driver.find_element(By.XPATH, type_elem1).click()  # 点击 Create下的acc Group选项
        # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_nameInput_posXpath).send_keys(
        #     self.my_item_name)  # 于Name输入框键入上述随机Name
        self._operate_name(data, no_modify=None)  # 于Name输入框键入上述随机Name
        # 点击并校验Exclude Objects
        exclude_objects_switch_elem = self.driver.find_element(By.XPATH,
                                                               accGroup_ObjectDetailPage_excludeObjectsSwitch_posXpath)
        exclude_objects_switch_elem.click()  # 从关闭到开启
        # print(exclude_objects_switch_elem.get_attribute("class"))

        try:
            assert exclude_objects_switch_elem.get_attribute(
                "class") == "MuiButtonBase-root MuiSwitch-switchBase MuiSwitch-colorPrimary Mui-checked PrivateSwitchBase-root MuiSwitch-switchBase MuiSwitch-colorPrimary Mui-checked Mui-checked css-y2jqxi", "Exclude Objects Switch未被开启！！"
            print("Exclude Objects Switch成功开启")
            self.driver.isElementExist(accGroup_ObjectDetailPage_excludeObjects_itemsArea_posXpath)
            assert self.driver.Exist, "Exclude Objects未开启！！"
            print("Exclude Objects 成功开启")
        except Exception as e:
            print(e)
            raise

        exclude_objects_switch_elem.click()  # 从开启到关闭
        try:
            assert exclude_objects_switch_elem.get_attribute(
                "class") == "MuiButtonBase-root MuiSwitch-switchBase MuiSwitch-colorPrimary PrivateSwitchBase-root MuiSwitch-switchBase MuiSwitch-colorPrimary css-y2jqxi", "Exclude Objects Switch未被关闭！！"
            print("Exclude Objects Switch成功关闭")
            self.driver.isElementExist(accGroup_ObjectDetailPage_excludeObjects_itemsArea_posXpath)
            assert not self.driver.Exist, "Exclude Objects未关闭！！"
            print("Exclude Objects 成功关闭")
        except Exception as e:
            print(e)
            raise

        exclude_objects_switch_elem.click()  # 从关闭到开启
        # 未添加exclude_objects便点击保存
        ##点击OK
        for i in range(3):
            self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()
        ###捕获error messages并校验
        try:
            # self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 再次点击OK
            error_message = self.driver.find_element(By.XPATH, '//div[@class="account-object-included_sub_object_uuids"]/div[2]').text
            print(error_message)
            # assert error_message == "Subordinate objects of an object cannot contain only excluded objects", "error_message 校验失败"
            assert error_message in "Subordinate Objects cannot be empty", "error_message 校验失败"
        except Exception as e:
            print(e)
            raise

        # 添加子item
        # self.driver.find_element(By.XPATH,
        #                          accGroup_ObjectDetailPage_excludeObjectsSwitch_newAdd_posXpath).click()  # 点击无数据新增按钮
        # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_firstObject).click()  # 选择第一个acc Object
        # self.driver.find_element(By.XPATH,
        #                          acc_ObjectGroupDetailPage_subObjects_toggleDraw_closeButton_posXpath).click()  # acc侧滑窗口的Close按钮
        # self.driver.find_element(By.XPATH,
        #                          accGroup_ObjectDetailPage_excludeObjectsSwitch_normalAdd_posXpath).click()  # 点击有数据新增按钮
        # time.sleep(1)
        # self.driver.find_element(By.XPATH, acc_ObjectDetailPage_secondObject).click()  # 选择第二个acc Object
        # 添加子item
        self.driver.find_element(By.XPATH,
                                 accGroup_ObjectDetailPage_excludeObjectsSwitch_newAdd_posXpath).click()  # 点击无数据新增按钮
        # 点击Accounts侧滑窗口的"+"按钮
        self.driver.find_element(By.XPATH, acc_ObjectGroupDetailPage_subObjects_toggleDraw_addButton_posXpath).click()
        time.sleep(0.5)
        # 点击Accounts侧滑窗口的"+"按钮下的Account
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_toggleDraw_addButton_account_posXpath).click()
        my_sub_item_name = self._operate_sub_name(data, self.my_random.random_account())  # name
        self._input_sub_name(my_sub_item_name)  # 键入name
        self._sub_items_acc_add(self.my_random.random_account())  # items
        self._operate_sub_description(data)  # description
        self._sub_object_detail_page_save()
        # ##点击OK
        # for i in range(3):
        #     self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()

        ###捕获error messages并校验
        try:
            time.sleep(3)
            self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()  # 再次点击OK
            error_message = self.driver.find_element(By.XPATH, '//div[@class="account-object-included_sub_object_uuids"]/div[2]').text
            print(error_message)
            # assert error_message == "Subordinate objects of an object cannot contain only excluded objects", "error_message 校验失败"
            assert error_message in "Subordinate Objects cannot be empty", "error_message 校验失败"
        except Exception as e:
            print(e)
            raise
        self._del(data)

    @screenshot_on_failure
    def _choose_single_object_method(self):
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        self.driver.find_element(By.XPATH, acc_listPage_createButton_account_posId).click()  # 点击Create下的Acc 选项

    @screenshot_on_failure
    def _choose_group_object_method(self):
        self.driver.find_element(By.XPATH, acc_listPage_createButton_posXpath).click()  # 点击Create按钮
        self.driver.find_element(By.XPATH, acc_listPage_createButton_accountGroup_posId).click()  # 点击Create下的Acc Group选项
        # self.driver.find_element(By.ID, listPage_object_ip_address_createButton_posId).click()  # 点击Create按钮
        # self.driver.find_element(By.ID,
        #                          listPage_object_ip_address_create_ip_address_Group_Button_posId).click()  # 点击Create下的IP Group选项

    @screenshot_on_failure
    def _turnPagesInSubObjectsDrawer(self, data):
        page_flag = 2  # 2-对象组添加对象时的侧滑列表页
        # 页面跳转
        self._just_goto_accountsPage()

        # 进入新建Group Object页面
        self._choose_group_object_method()
        # 添加sub Object 按钮并展开侧滑窗口
        self.driver.find_element(By.XPATH,
                                 acc_ObjectGroupDetailPage_subObjects_addButton_newAdd_posXpath).click()  # 点击Subordinate Objects + 按钮
        self.objects_po.pages_turning(data, page_flag=page_flag)
        # # 数据量不够翻页时：
        # max_page_elem_Xpath = DrawerlistPage_object_pages_maxPageNumber_posXpath
        # if not self.driver.element_isExist(By.XPATH, max_page_elem_Xpath):
        #     # 切换Vsys 至Vsys0
        #     vsys_name = self.loginout_parse.get("vsys0", "vsys_name")
        #
        #     self.profile_pub.change_vsys(vsys_name=vsys_name)
        #     # 页面跳转
        #     self._just_goto_accountsPage()
        #     # 进入新建Group Object页面
        #     self._choose_group_object_method()
        #     # 添加sub Object 按钮并展开侧滑窗口
        #     self.driver.find_element(By.XPATH,
        #                              acc_ObjectGroupDetailPage_subObjects_addButton_newAdd_posXpath).click()  # 点击Subordinate Objects + 按钮
        #     if self.driver.element_isExist(By.XPATH, max_page_elem_Xpath):
        #         # 侧滑窗口中翻页操作
        #         self.objects_po.pages_turning(data, page_flag=2)
        #     else:  # 页面不足，无法进行翻页操作--跳过
        #         print(" 页面不足，无法进行翻页操作--跳过")
        #         pass
        # else:
        #     # 侧滑窗口中翻页操作
        #     self.objects_po.pages_turning(data, page_flag=page_flag)

    @screenshot_on_failure
    def _clear_counter(self, data):
        """
        测试点：
            # 列表页
                ##单选Object
                ##多选Object
                ##多选Object 和Object Group
                ##单选非本Vsys Object
            # 详情页
                ##Object详情页
                ##Object Group详情页
                ##非本Vsys的Object详情页
        :return:
        """
        # 于data中获取数据
        page_flag, selected_object_type, selected_objects_number, detail_type, selected_data_number = data["page_flag"], \
            data["selected_object_type"], data["selected_objects"], data["detail_type"], data["selected_data"]
        print(page_flag, selected_object_type, selected_objects_number, detail_type)
        self.obj_data = {"Model": "create",
                         "Type": 1,
                         "Name": "test_ui 4 Clear Counter",
                         "Items": [],
                         "Description": "",
                         "Subordinate Objects": {
                             "subName": "test_ui 4 Clear Counter",
                             "subItems": [
                                 "[random]->"
                             ],
                             "subDescription": ""
                         }}
        obj_data = self.obj_data
        # 判断当前页是否有符合条件的测试数据
        create_data_flag = 0
        try:
            self._just_goto_accountsPage()  # 页面跳转
            self.driver.implicitly_wait(5)
            is_firstObjectGroup_exist = self.driver.element_isExist(By.XPATH,
                                                                    acc_listPage_object_tableCheckbox_firstObjectGroup_posXpath)
            is_firstSingleObject_exist = self.driver.element_isExist(By.XPATH,
                                                                     acc_listPage_object_tableCheckbox_firstSingleObject_posXpath)
            if is_firstObjectGroup_exist is False or is_firstSingleObject_exist is False:
                # 创建测试数据
                self._create(data=obj_data)
                create_data_flag = 1
            # else:
            #     firstSingleObject = self.driver.find_element(By.XPATH,
            #                                                  acc_listPage_object_tableCheckbox_firstSingleObject_posXpath)
            #     firstObjectGroup = self.driver.find_element(By.XPATH,
            #                                                 acc_listPage_object_tableCheckbox_firstObjectGroup_posXpath)
            #     firstNotLocalVsysObjectOrGroup = self.driver.find_element(By.XPATH,
            #                                                               acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
            #
            #     if firstSingleObject == firstNotLocalVsysObjectOrGroup or firstObjectGroup == firstNotLocalVsysObjectOrGroup:
            #         # 创建测试数据
            #         self._create(data=obj_data)
            #         create_data_flag = 1
            #     else:
            #         pass

        except Exception as e:
            print(e)
            raise e
        try:
            if page_flag == 0:  # 列表页
                self._pure_operate_checkbox(selected_object_type, selected_objects_number)  # 列表页选择操作
                self._verify_clear_counter(page_flag, selected_object_type, selected_objects_number,
                                           selected_data_number,
                                           detail_type)
            else:  # 详情页
                # 判断进入何种类型的Object的详情页
                self._judge_whitch_page(detail_type)
                self._verify_clear_counter(page_flag, selected_object_type, selected_objects_number,
                                           selected_data_number,
                                           detail_type)
        except Exception as e:
            raise e
        finally:
            # 页面跳转
            self.driver.refresh()
            # 清除测试数据
            if create_data_flag == 1:  # 已新建数据
                # 切换Vsys至 uivsys

                vsys_name = self.loginout_parse.get("vsys", "vsys_name")  # 登录后vsys切换为UIAutoTestVsys
                self.profile_pub.change_vsys(vsys_name=vsys_name)
                self._just_goto_accountsPage()
                self._del(obj_data, search_value="test_ui 4 Clear Counter", del_flag=1)
            elif self.create_other_vsys_data_flag == 1:  # 已创建其他Vsys数据
                # 切换Vsys至vsys0
                vsys_name = self.loginout_parse.get("vsys0", "vsys_name")  # 登录后vsys切换为UIAutoTestVsys
                self.profile_pub.change_vsys(vsys_name=vsys_name)
                self._just_goto_accountsPage()
                self._del(obj_data, search_value="test_ui 4 Clear Counter", del_flag=1)

    @screenshot_on_failure
    def _judge_whitch_page(self, detail_type):
        """
         #判断进入何种类型的Object的详情页
        :param detail_type:
        :return:
        """
        self.create_other_vsys_data_flag = 0
        if detail_type == 0:  # Object详情页
            # 选中第一个Object并进入其详情页
            self.driver.find_element(By.XPATH, acc_listPage_object_tableCheckbox_firstSingleObject_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮
        elif detail_type == 1:  # Object Group详情页
            # 选中第一个Object Group并进入其详情页
            self.driver.find_element(By.XPATH, acc_listPage_object_tableCheckbox_firstObjectGroup_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮

        else:  # etail_type=2--非本Vsys的Object详情页
            # 判断当前页有无非本Vsys的对象
            is_firstNotLocalVsys_exist = self.driver.element_isExist(By.XPATH,
                                                                     acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
            try:
                if is_firstNotLocalVsys_exist == True:
                    pass
                else:
                    # 先进行一次翻页查找
                    # #获取页面中最大页码
                    max_page_elem_Xpath = listPage_object_pages_maxPageNumber_posXpath
                    max_page_number = self.driver.find_element(By.XPATH, max_page_elem_Xpath).text
                    int_max_page_number = int(max_page_number)
                    if int_max_page_number != 1:
                        data = {"turn_mode": 1,
                                "destination_page": max_page_number}
                        self.objects_po.pages_turning(data)
                        is_firstNotLocalVsys_exist = self.driver.element_isExist(By.XPATH,
                                                                                 acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
                        loop_count = int(int(max_page_number) / 2) + (
                                int(max_page_number) / 2 > int(int(max_page_number) / 2))  # 最大翻页次数
                        while not is_firstNotLocalVsys_exist:
                            int_max_page_number -= 1
                            data = {"turn_mode": 1,
                                    "destination_page": str(int_max_page_number)}
                            self.objects_po.pages_turning(data)
                            is_firstNotLocalVsys_exist = self.driver.element_isExist(By.XPATH,
                                                                                     acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
                            loop_count -= 1
                            if is_firstNotLocalVsys_exist:
                                break
                            if loop_count < 1:
                                break
                    # 仍无则在vsys0寻找
                    # #切换Vsys至vsys0
                    vsys_name = self.loginout_parse.get("vsys0", "vsys_name")  # 登录后vsys切换为UIAutoTestVsys
                    self.profile_pub.change_vsys(vsys_name=vsys_name)
                    self._just_goto_accountsPage()
                    is_firstNotLocalVsys_exist = self.driver.element_isExist(By.XPATH,
                                                                             acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
                    # 仍无则创建测试数据
                    if not is_firstNotLocalVsys_exist:
                        # 创建测试数据
                        obj_data = self.obj_data
                        # # 切换Vsys至vsys0
                        # vsys_name = self.loginout_parse.get("vsys0", "vsys_name")  #
                        # # profile_pub = ProfilesPublicOperations(driver)
                        # profile_pub.change_vsys(vsys_name=vsys_name)
                        self._create(data=obj_data)
                        ui_vsys_name = self.loginout_parse.get("vsys", "vsys_name")  # 切换为UIAutoTestVsys
                        profile_pub.change_vsys(vsys_name=ui_vsys_name)
                        self.create_other_vsys_data_flag = 1
            except Exception as e:
                print(e)
            # 选中第一个非本Vsys的Object Group或Object并进入其详情页
            self.driver.find_element(By.XPATH,
                                     acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # 点击edit按钮

    @screenshot_on_failure
    def _pure_operate_checkbox(self, selected_object_type, selected_objects_number):
        """

        :param selected_object_type: 上层传入，
            selected items Type=0选中对象，
            selected items Type=1则选中对象组,
            selected items Type=2则选中对象和对象组，
            selected items Type=3则任意非本Vsys的对象",
        :return:
        """
        self.verify_selected_objects_number0 = 0
        self.create_other_vsys_data_flag = 0
        if selected_object_type == 0:  # 选中对象
            local_vsys_object_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                         acc_listPage_object_tableCheckbox_singleObject_posXpaths)  # 定位所有single object对应的CheckBox
            # object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
            #                                                                  acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
            # # 处理object_checkbox_elems，将不是本Vsys的checkbox元素剔除
            # local_vsys_object_checkbox_elems = self._operate_webelmet_group(object_checkbox_elems,
            #                                                                 object_not_local_vsys_checkbox_elems)
            if selected_objects_number == 0:  # 选中个数为0
                self.verify_selected_objects_number0 = 1
            else:  # 选中头selected_objects 个对象
                if selected_objects_number == -1:  # 选中个数为随机
                    if len(local_vsys_object_checkbox_elems) == 1:
                        self.random_selected_objects_number = 1
                    # elif len(local_vsys_object_checkbox_elems) == 0:
                    #     selected_objects_number = 1
                    else:
                        self.random_selected_objects_number = random.randint(1, len(local_vsys_object_checkbox_elems))
                    selected_objects_number = self.random_selected_objects_number
                else:  # 采用用例中的数值
                    selected_objects_number = selected_objects_number
                for index in range(len(local_vsys_object_checkbox_elems)):
                    if selected_objects_number < 1:
                        break
                    try:
                        # 使用显式等待确保元素可点击
                        element = self.wait.until(EC.presence_of_element_located((By.XPATH,
                                                                                  listPage_object_urls_tableCheckbox_singleObject_posXpaths_template.format(
                                                                                      index + 1))))
                        element.click()
                        selected_objects_number -= 1
                    except StaleElementReferenceException:
                        # 如果发生StaleElementReferenceException，重新获取元素并尝试点击
                        local_vsys_object_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                                     listPage_object_urls_tableCheckbox_singleObject_posXpaths)  # 定位所有single object对应的CheckBox
                        local_vsys_object_checkbox_elems[index].click()
                        selected_objects_number -= 1

        elif selected_object_type == 1:  # 1则选中对象组
            # 定位对象组
            object_group_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                    acc_listPage_object_tableCheckbox_objectGroup_posXpaths)
            object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                             acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
            # 处理object_checkbox_elems，将不是本Vsys的checkbox元素剔除
            local_vsys_object_group_checkbox_elems = self._operate_webelmet_group(object_group_checkbox_elems,
                                                                                  object_not_local_vsys_checkbox_elems)
            if selected_objects_number == 0:  # 选中个数为0
                self.verify_selected_objects_number0 = 1
                # pass
            else:  # 选中头selected_objects 个对象
                if selected_objects_number == -1:  # 选中个数为随机
                    self.random_selected_objects_number = random.randint(1, len(local_vsys_object_group_checkbox_elems))
                    selected_objects_number = self.random_selected_objects_number
                else:  # 选中个数为确切值
                    if selected_objects_number > len(local_vsys_object_group_checkbox_elems):  # 用例中参数大于实际页面展示的数目
                        selected_objects_number = len(local_vsys_object_group_checkbox_elems)
                    else:  # 采用用例中的数值
                        selected_objects_number = selected_objects_number
                for i in local_vsys_object_group_checkbox_elems:
                    if selected_objects_number < 1:
                        break
                    else:
                        i.click()
                        selected_objects_number -= 1

        elif selected_object_type == 2:  # 2则选中对象和对象组
            # 定位所有single object对应的CheckBox
            object_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                              acc_listPage_object_tableCheckbox_singleObject_posXpaths)
            # 定位对象组
            object_group_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                    acc_listPage_object_tableCheckbox_objectGroup_posXpaths)
            object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                             acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
            # 处理object_checkbox_elems，将不是本Vsys的checkbox元素剔除
            local_vsys_object_checkbox_elems = self._operate_webelmet_group(object_checkbox_elems,
                                                                            object_not_local_vsys_checkbox_elems)
            local_vsys_object_group_checkbox_elems = self._operate_webelmet_group(object_group_checkbox_elems,
                                                                                  object_not_local_vsys_checkbox_elems)

            if selected_objects_number == 0:  # 选中个数为0
                # pass
                self.verify_selected_objects_number0 = 1

            else:  # 选中头selected_objects 个对象
                if selected_objects_number == -1:  # 选中个数为随机
                    self.random_selected_objects_number = random.randint(1,
                                                                         len(local_vsys_object_group_checkbox_elems) + len(
                                                                             local_vsys_object_checkbox_elems))
                    selected_objects_number = self.random_selected_objects_number
                else:  # 选中个数为确切值
                    if selected_objects_number > len(local_vsys_object_group_checkbox_elems) + len(
                            local_vsys_object_checkbox_elems):  # 用例中参数大于实际页面展示的数目
                        selected_objects_number = len(local_vsys_object_group_checkbox_elems) + len(
                            local_vsys_object_checkbox_elems)
                    else:  # 采用用例中的数值
                        selected_objects_number = selected_objects_number
                for i in local_vsys_object_group_checkbox_elems:
                    if selected_objects_number == 1:  # 剩余一个，用于勾选单独对象
                        break
                    else:
                        i.click()
                        print("i.click()")
                        selected_objects_number -= 1
                for j in local_vsys_object_checkbox_elems:
                    if selected_objects_number < 1:
                        break
                    else:
                        j.click()
                        print("j.click()")
                        selected_objects_number -= 1

        else:  # 3则任意非本Vsys的对象
            object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                             acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
            if len(object_not_local_vsys_checkbox_elems) == 0:
                # 先进行一次翻页查找
                # #获取页面中最大页码
                max_page_elem_Xpath = listPage_object_pages_maxPageNumber_posXpath
                max_page_number = self.driver.find_element(By.XPATH, max_page_elem_Xpath).text
                int_max_page_number = int(max_page_number)
                if int_max_page_number != 1:
                    data = {"turn_mode": 1,
                            "destination_page": max_page_number}
                    self.objects_po.pages_turning(data)
                    object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                                     acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
                    loop_count = int(int(max_page_number) / 2) + (
                            int(max_page_number) / 2 > int(int(max_page_number) / 2))  # 最大翻页次数
                    while len(object_not_local_vsys_checkbox_elems) == 0:
                        int_max_page_number -= 1
                        data = {"turn_mode": 1,
                                "destination_page": str(int_max_page_number)}
                        self.objects_po.pages_turning(data)
                        object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                                         acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
                        loop_count -= 1
                        if len(object_not_local_vsys_checkbox_elems) != 0:
                            break
                        if loop_count < 1:
                            break
            # 仍无则在vsys0寻找
            # #切换Vsys至vsys0
            vsys_name = self.loginout_parse.get("vsys0", "vsys_name")  # 登录后vsys切换为UIAutoTestVsys
            self.profile_pub.change_vsys(vsys_name=vsys_name)
            ## 页面跳转
            self._just_goto_accountsPage()
            object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                             acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
            # 仍无则新建测试数据
            if len(object_not_local_vsys_checkbox_elems) == 0:
                obj_data = self.obj_data
                # # 切换Vsys
                # # 切换Vsys至vsys0
                # vsys_name = self.loginout_parse.get("vsys0", "vsys_name")  # 登录后vsys切换为UIAutoTestVsys
                # self.profile_pub.change_vsys(vsys_name=vsys_name)
                self._create(data=obj_data)
                self.create_other_vsys_data_flag = 1
            if selected_objects_number == 0:  # 选中个数为0
                # pass
                self.verify_selected_objects_number0 = 1
            else:  # 选中头selected_objects 个对象
                object_not_local_vsys_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                                                 acc_listPage_object_tableCheckbox_notLocalVsys_objectOrGroup_posXpaths)  # 列表页中不是本Vsys的对象或对象组的CheckBox
                if selected_objects_number == -1:  # 选中个数为随机
                    self.random_selected_objects_number = random.randint(1, len(object_not_local_vsys_checkbox_elems))
                    selected_objects_number = self.random_selected_objects_number
                else:  # 采用用例中的数值
                    selected_objects_number = selected_objects_number
                for i in object_not_local_vsys_checkbox_elems:
                    if selected_objects_number < 1:
                        break
                    else:
                        i.click()
                        selected_objects_number -= 1

    def _operate_webelmet_group(self, group1, group2):
        """
        处理WebElemet Group(将1中的2元素排除掉)
        :param group1:
        :param group2:
        :return:
        """
        # 将group 转换为set 便于排除处理
        set_group1 = set(group1)
        set_group2 = set(group2)
        # 使用集合差集来排除 elements_group2 中的元素
        filtered_set = set_group1 - set_group2
        # 将结果转换回列表
        filtered_elements = list(filtered_set)
        return filtered_elements

    @screenshot_on_failure
    def _select_objects_secondSelect(self, selected_objects_number, selected_data_number):
        """
        处理列表页选择的二次确认弹窗
        :param selected_data_number: 二次弹窗中要选择的数目
        :param selected_object_type: 选择的类型
        :return:
        """

        # 处理二次确认弹窗
        self.driver.find_element(By.XPATH,
                                 acc_listPage_object_exportPopSelectAll_posXpath).click()  # 点击全选按钮，取消默认全选
        data_checkbox_elems = self.driver.find_elements(By.XPATH,
                                                        acc_listPage_object_exportPopCheckbox_posXpaths)  # 导出弹窗数据CheckBox
        if selected_data_number != 0:
            if selected_data_number > 0:
                selected_data_number = selected_data_number
            elif selected_data_number == -1:  # 随机数值
                selected_data_number = random.randint(1, self.random_selected_objects_number)
            clickable_flag = 1
            for i in range(len(data_checkbox_elems)):
                if selected_data_number < 1:
                    break
                else:
                    element = self.wait.until(EC.presence_of_element_located((By.XPATH,
                                                                              listPage_object_urls_exportPopCheckbox_posXpaths_template.format(
                                                                                  i + 1))))
                    self.driver.execute_script("arguments[0].scrollIntoView();", element)
                    element.click()
                    selected_data_number -= 1
        else:  # selected_data_number = 0确认弹窗中不选择数据
            clickable_flag = 0
        return clickable_flag

    @screenshot_on_failure
    def _verify_clear_counter(self, page_flag, selected_object_type, selected_objects_number, selected_data_number,
                              detail_type):
        """
        page_flag =0时默认已勾选元素，page_flag =1默认已进入Object 详情页
        :param page_flag:
        :return:
        """

        if page_flag == 0:  # 列表页操作与验证
            if selected_object_type != 3:  # 不是选择非本Vsys的数据
                # 点击Clear Counter按钮
                self.driver.find_element(By.XPATH, listPage_object_pages_clearCounter_button_poxXpath).click()
                if self.verify_selected_objects_number0 == 1:  # 未选择任何数据
                    error_message_elem_isExist = self.driver.element_isExist(By.XPATH,
                                                                             '//div[@role="alert" and contains(@class,"el-message el-message--error")]')
                    assert error_message_elem_isExist == True, "校验失败！无错误提示"
                else:
                    # 处理二次确认弹窗
                    clickable_flag = self._select_objects_secondSelect(selected_objects_number, selected_data_number)
                    if clickable_flag == 1:  # 确认弹窗中的确认按钮可点击
                        try:
                            is_disabled = self.driver.find_element(By.XPATH,
                                                                   acc_listPage_object_clearCounterPopYes_posXpath).get_attribute(
                                "disabled")
                        except:
                            is_disabled = None
                            pass
                        assert is_disabled == None, "校验失败！此时按钮不可点击"
                    else:  # 确认弹窗中的确认按钮不可点击
                        try:
                            is_disabled = self.driver.find_element(By.XPATH,
                                                                   acc_listPage_object_clearCounterPopYes_posXpath).get_attribute(
                                "disabled")
                        except:
                            is_disabled = None
                            pass
                        assert is_disabled == 'disabled', "校验失败！此时按钮可点击"

            else:  # 校验非本Vsys的数据
                # is_clear_counter_clickable = self.objects_po.is_element_clickable(
                #     listPage_object_pages_clearCounter_button_poxXpath, "XPATH")
                is_clear_counter_clickable = self.driver.find_element(By.XPATH,
                                                                      listPage_object_pages_clearCounter_button_poxXpath).get_attribute(
                    "class")
                assert "notAllowed" in is_clear_counter_clickable, "is_clear_counter_clickable ={}".format(
                    is_clear_counter_clickable)
        else:  # page_flag =1:  #详情页操作与验证
            # Clear Counter按钮
            is_clear_counter_clickable = self.driver.find_element(By.XPATH,
                                                                  acc_ObjectDetailPage_clearCounter_posXpath).get_attribute(
                "class")
            if detail_type != 2:  # 不是非本Vsys的详情页
                assert "not-allowed" not in is_clear_counter_clickable, "is_clear_counter_clickable = {}".format(
                    is_clear_counter_clickable)
            else:  # 非本Vsys的详情页
                assert "not-allowed" in is_clear_counter_clickable, "is_clear_counter_clickable = {}".format(
                    is_clear_counter_clickable)

    @screenshot_on_failure
    def _view_statistics_case(self, data):
        try:
            self._just_goto_accountsPage()
            self._create(data)
            self._simple_query(data, data["Name"])
            self.objects_po.View_statistics(edit_element=listpage_edit_button_posXpath)
        except Exception as e:
            raise e
        finally:
            self._del(data)

    @screenshot_on_failure
    def _item_duplicate_check(self, data):
        # 新建1个对象
        if "repetition_type" in data and data["repetition_type"] != "0":
            need_delete = False
        else:
            self._create(data)
            need_delete = True
            data["repetition_type"] = "0"
        try:
            # 新建另一个重复对象
            # 跳转至对象创建页面
            self._just_goto_accountsPage()

            # 页面选项操作
            if data["Model"] == "modify":
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()
                self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()
                self._operate_page(data, operation_type="modify")
            else:
                # 选择创建模式，single or group
                self._create_type(data)
                self._operate_page(data, operation_type="create")
            # 校验
            self.objects_po.verify_duplicate_items(data, obj_type="accounts")
        except Exception as e:
            raise e
        finally:
            if need_delete:
                # 清理测试数据
                self.driver.refresh()
                self._del(data)

    def _verify_duplicate_items(self, data):
        self.driver.isElementExist(Element=listPage_object_reprtition_check_postXpath)
        assert self.driver.Exist, "校验失败！！重复标志不存在！！"
        if data["repetition_type"] == "0":
            # 侧滑部分校验
            self.driver.find_element(By.XPATH, listPage_object_reprtition_check_postXpath).click()
            total_count = self.driver.find_element(By.XPATH,
                                                   "//div[@class='tab-content floatleft height100 width100']/p").text
            count = total_count.split("Total:")
            assert int(count[1]) >= 1, "校验失败！"
            # 悬浮框内容校验
            element_to_hover_over = self.driver.find_element(By.XPATH,
                                                             "//div[@class='TableList floatleft overflow-y-auto width100']//div[@class='reference-box el-popover__reference']/span")
            ActionChains(self.driver).move_to_element(element_to_hover_over).perform()
            tooltip = WebDriverWait(self.driver, 10).until(
                EC.visibility_of_element_located((By.XPATH, '//div[contains(@x-placement,"-start")]')))
            # 行符分割为列表
            hover_tooltip = tooltip.text.splitlines()
            # 列表转换为字典
            result_dict = {}
            for i in range(0, len(hover_tooltip), 2):
                if i + 1 < len(hover_tooltip):  # 确保存在下一行
                    key = hover_tooltip[i].strip()  # 去除首尾空格作为键
                    value = hover_tooltip[i + 1].strip()  # 去除首尾空格作为值
                    result_dict[key] = value
            try:
                data_item = data["Items"][0].split("->")[0].strip()
                tooltip_item = result_dict["Item"].strip()
                assert data_item == tooltip_item
            except KeyError:
                # assert list(data["Create"]["item"].values())[0] == result_dict["Item"].strip()[0]
                raise KeyError

    @screenshot_on_failure
    def _onlyViewPermission(self):
        # 页面跳转
        self._goto_accountsPage()
        # 定位无权限对象
        try:
            # self.driver.find_element(By.XPATH, acc_listPage_object_tableCheckbox_localVsys_firstObjectOrGroup_posXpaths)
            # 判断目标元素是否存在
            is_noPermissong_elm_exsit = self.driver.element_isExist(By.XPATH,
                                                                    acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
            if not is_noPermissong_elm_exsit:
                # 获取页面中最大页码
                max_page_elem_Xpath = listPage_object_pages_maxPageNumber_posXpath
                max_page_number = int(self.driver.find_element(By.XPATH, max_page_elem_Xpath).text)
                while not is_noPermissong_elm_exsit and max_page_number > 1:
                    # 翻页
                    self.objects_po.pages_turning(
                        data={"turn_mode": 1, "destination_page": "{}".format(max_page_number)})
                    # 判断目标元素是否存在
                    is_noPermissong_elm_exsit = self.driver.element_isExist(By.XPATH,
                                                                            acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath)
                    if is_noPermissong_elm_exsit:
                        break
                    max_page_number -= 1
            # 选中目标对象
            self.driver.find_element(By.XPATH,
                                     acc_listPage_object_tableCheckbox_firstNotLocalVsys_objectOrGroup_posXpath).click()
            target_object_is_not_exist = False
        except Exception as e:
            assert False, "当前列表页内无适用Objects！！暂未进行校验"
            # 校验此时View按钮存在
        is_view_button_exsit = self.driver.element_isExist(By.XPATH,
                                                           '//button//*[@class="iconfont icon-View"]')
        assert is_view_button_exsit, "校验失败，此时View按钮存在为{}".format(is_view_button_exsit)

    @screenshot_on_failure
    def check_link_case(self, data, link_list_dict):
        # link简单link校验测试
        """
        :param data: link_list_dict=[{"link_dst_cluster": "42.49-User4Link", "link_dst_vsys":"Vsys2test", "url": "http://192.168.42.49/#/login","username": "admin","passwd": "admin"}])
        :param link_list_dict:
        :return:
        """

        self._just_goto_accountsPage()
        self._create(data)
        time.sleep(3)
        self._query(data)
        time.sleep(2)
        self.first_row_checkBox_element = self.driver.find_element(By.XPATH,
                                                                   "//div[@class='el-checkbox-group']//span[@class='el-checkbox__input']").click()  # 勾选第一行元素
        # 调用公共的link创建逻辑
        Des_ID_list, Request_ID, Sou_ID_list = self.objects_po._linkdata(link_list_dict, acc_listpage_linkButton_posId,
                                                                         acc_listpage_linkSave_posXpath,
                                                                         acc_listpage_linkAdd_posXpath,
                                                                         acc_listpage_linkOk_posXpath)
        try:
            profile_public = ProfilesPublicOperations(self.driver)
            profile_public.change_vsys(vsys_name="UIAutoTestVsys")
            self._just_goto_accountsPage()
            # 查询object
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(Sou_ID_list[0])
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(2)
            # 修改数据
            if data["Type"] == 0:
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 第一行数据前的复选框
                self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # edit按钮
                self.objects_po.clear_Name(path=ObjectDetailPage_input_Name_posXpath)  # 清除name
                self.driver.find_element(By.XPATH, ObjectDetailPage_input_Name_posXpath).send_keys(
                    data["modify_sou_name"])  # 重新输入name
                self.driver.find_element(By.XPATH, ip_addressObjectPage_button_editItem_posXpath).click()
                self.objects_po.clear_Name(path=acc_ObjectDetailPage_itemValueInput_poXpath)  # 清除item
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemValueInput_poXpath).send_keys(
                    data["modify_sou_item"])
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemSaveButton_poXpath).click()
                self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()
                self.driver.find_element(By.XPATH, ObjectDetailPage_okButton_yes_posXpath).click()
            else:
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 第一行数据前的复选框
                self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # edit按钮
                self.objects_po.clear_Name(path=ObjectDetailPage_input_Name_posXpath)  # 清除name
                self.driver.find_element(By.XPATH, ObjectDetailPage_input_Name_posXpath).send_keys(
                    data["modify_sou_name"])  # 重新输入name
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_editgroup_posXpath).click()
                self.driver.find_element(By.XPATH, ip_addressObjectPage_button_editItem_posXpath).click()
                self.objects_po.clear_Name(path=acc_ObjectDetailPage_itemValueInput_poXpath)  # 清除item
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemValueInput_poXpath).send_keys(
                    data["modify_sou_item"])
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemSaveButton_poXpath).click()
                self.driver.find_element(By.XPATH,
                                         acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_posXpath).click()
                self.driver.find_element(By.XPATH,
                                         acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_yes_posXpath).click()
                self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()
                self.driver.find_element(By.XPATH, ObjectDetailPage_okButton_yes_posXpath).click()
            self._just_goto_accountsPage()
            # 查询object
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(Sou_ID_list[0])
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(2)
            # 获取修改后的数据
            sou_value_name = self.driver.find_element(By.XPATH,
                                                      "//div[contains(@class,'el-table__body-wrapper')]//tr[1]//td[count(//div[@class='el-table__header-wrapper']//span[text()='Name']/../../../preceding-sibling::th)+1]//span").text
            sou_value_detail = self.driver.find_element(By.XPATH,
                                                        "//div[contains(@class,'el-table__body-wrapper')]//tr[1]//td[count(//div[@class='el-table__header-wrapper']//span[text()='Details']/../../../preceding-sibling::th)+1]//span").text
            # 调用公用的sync点击逻辑
            Request_ID = self.objects_po.click_sync(Request_ID)
            time.sleep(3)
            Request_ID, compare_list_name, compare_list_detail = self._del_linkDstData(Des_ID_list, Request_ID,
                                                                                       link_list_dict, data)
            # 列表去重
            compare_list_name.append(sou_value_name)
            print(compare_list_name)
            compare_list_detail.append(sou_value_detail)
            print(compare_list_detail)
            res_name = []
            res_detail = []
            for i in compare_list_name:
                if i not in res_name:
                    res_name.append(i)
            for i in compare_list_detail:
                if i not in res_detail:
                    res_detail.append(i)
            assert len(res_name) == 1 and len(res_detail) == 1
        finally:
            loginout = LogInOut(self.driver)
            loginout.logout()
            for link_index in range(len(link_list_dict)):
                loginout.login_other(url=link_list_dict[link_index]["url"],
                                     username=link_list_dict[link_index]["username"],
                                     passwd=link_list_dict[link_index]["passwd"])
                profile_public = ProfilesPublicOperations(self.driver)
                profile_public.change_vsys(vsys_name=link_list_dict[link_index]["link_dst_vsys"])
            self._just_goto_accountsPage()
            self._delete_des(Des_ID_list, data)  # 删除数据
            time.sleep(3)
            # 删除policy links记录
            self.objects_po._del_policy_links(Request_ID)
            # 删除源vsys数据
            self._delete_sou(Sou_ID_list, data)

    @screenshot_on_failure
    def _del_linkDstData(self, Des_ID_list, Request_ID, link_list_dict, data):
        loginout = LogInOut(self.driver)
        loginout.logout()
        time.sleep(2)
        compare_list_name = []
        compare_list_detail = []
        for link_index in range(len(link_list_dict)):
            loginout.login_other(url=link_list_dict[link_index]["url"], username=link_list_dict[link_index]["username"],
                                 passwd=link_list_dict[link_index]["passwd"])
            profile_public = ProfilesPublicOperations(self.driver)
            profile_public.change_vsys(vsys_name=link_list_dict[link_index]["link_dst_vsys"])
            self._just_goto_accountsPage()
            # 搜索目的vsys数据
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(Des_ID_list[0])
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(2)
            # 获取sync后的值
            des_value_Name = self.driver.find_element(By.XPATH,
                                                      "//div[contains(@class,'el-table__body-wrapper')]//tr[1]//td[count(//div[@class='el-table__header-wrapper']//span[text()='Name']/../../../preceding-sibling::th)+1]//span").text
            compare_list_name.append(des_value_Name)
            des_value_detail = self.driver.find_element(By.XPATH,
                                                        "//div[contains(@class,'el-table__body-wrapper')]//tr[1]//td[count(//div[@class='el-table__header-wrapper']//span[text()='Details']/../../../preceding-sibling::th)+1]//span").text
            compare_list_detail.append(des_value_detail)
            # 在目的vsys中修改
            if data["Type"] == 0:
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 第一行数据前的复选框
                self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # edit按钮
                self.objects_po.clear_Name(path=ObjectDetailPage_input_Name_posXpath)  # 清除name
                self.driver.find_element(By.XPATH, ObjectDetailPage_input_Name_posXpath).send_keys(
                    data["modify_des_name"])  # 重新输入name
                self.driver.find_element(By.XPATH, ip_addressObjectPage_button_editItem_posXpath).click()
                self.objects_po.clear_Name(path=acc_ObjectDetailPage_itemValueInput_poXpath)  # 清除item
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemValueInput_poXpath).send_keys(
                    data["modify_des_item"])
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemSaveButton_poXpath).click()
                self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()
                self.driver.find_element(By.XPATH, ObjectDetailPage_okButton_yes_posXpath).click()
            else:
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 第一行数据前的复选框
                self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()  # edit按钮
                self.objects_po.clear_Name(path=ObjectDetailPage_input_Name_posXpath)  # 清除name
                self.driver.find_element(By.XPATH, ObjectDetailPage_input_Name_posXpath).send_keys(
                    data["modify_des_name"])  # 重新输入name
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_editgroup_posXpath).click()
                self.driver.find_element(By.XPATH, ip_addressObjectPage_button_editItem_posXpath).click()
                self.objects_po.clear_Name(path=acc_ObjectDetailPage_itemValueInput_poXpath)  # 清除item
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemValueInput_poXpath).send_keys(
                    data["modify_des_item"])
                self.driver.find_element(By.XPATH, acc_ObjectDetailPage_itemSaveButton_poXpath).click()
                self.driver.find_element(By.XPATH,
                                         acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_posXpath).click()
                self.driver.find_element(By.XPATH,
                                         acc_ObjectGroupDetailPage_subObjects_subCreateAccountDrawer_okButton_yes_posXpath).click()
                self.driver.find_element(By.XPATH,acc_ObjectDetailPage_mainOkButton_posXpath).click()
                self.driver.find_element(By.XPATH, ObjectDetailPage_okButton_yes_posXpath).click()
            # 调用公用的sync点击逻辑
            Request_ID = self.objects_po.click_sync(Request_ID)
            if data["cluster_id"] == 2:
                loginout.login_other(url=link_list_dict[link_index]["url"],
                                     username=link_list_dict[link_index]["username"],
                                     passwd=link_list_dict[link_index]["passwd"])
                profile_public = ProfilesPublicOperations(self.driver)
                profile_public.change_vsys(vsys_name=link_list_dict[link_index]["link_dst_vsys"])
            else:
                profile_public = ProfilesPublicOperations(self.driver)
                profile_public.change_vsys(vsys_name=link_list_dict[link_index]["link_dst_vsys"])
            self._just_goto_accountsPage()
            # 搜索目的vsys数据
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(Des_ID_list[0])
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(2)
            # 再次获取sync后的值
            second_des_value_name = self.driver.find_element(By.XPATH,
                                                             "//div[contains(@class,'el-table__body-wrapper')]//tr[1]//td[count(//div[@class='el-table__header-wrapper']//span[text()='Name']/../../../preceding-sibling::th)+1]//span").text
            compare_list_name.append(second_des_value_name)
            second_des_value_detail = self.driver.find_element(By.XPATH,
                                                               "//div[contains(@class,'el-table__body-wrapper')]//tr[1]//td[count(//div[@class='el-table__header-wrapper']//span[text()='Details']/../../../preceding-sibling::th)+1]//span").text
            compare_list_detail.append(second_des_value_detail)

        return Request_ID, compare_list_name, compare_list_detail

    def _delete_des(self, Des_ID_list, data):
        if data["Type"] == 0:
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(Des_ID_list[0])
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(1)
            self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 选择第一个对象
            # 确认删除
            self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()
            self.driver.find_element(By.XPATH, listPage_object_ip_address_del_yes_Button_posXpath).click()
        else:
            for id in Des_ID_list:
                self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(id)
                self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
                self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
                time.sleep(1)
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 选择第一个对象
                # 确认删除
                self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()
                self.driver.find_element(By.XPATH, listPage_object_Keywords_del_yes_Button_posXpath).click()

    def _delete_sou(self, Sou_ID_list, data):
        loginout = LogInOut(self.driver)
        loginout.logout()
        time.sleep(1)
        loginout.login_other(url="http://192.168.44.72/#/login",
                             username=self.loginout_parse.get("ui_account_1", "username"),
                             passwd=self.loginout_parse.get("ui_account_1", "passwd"))
        # 删除数据
        profile_public = ProfilesPublicOperations(self.driver)
        profile_public.change_vsys(vsys_name="UIAutoTestVsys")
        self._just_goto_accountsPage()
        self._delete_source(Sou_ID_list, data)  # 删除数据

    def _delete_source(self, Sou_ID_list, data):
        if data["Type"] == 0:
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(Sou_ID_list[0])
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(1)
            self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 选择第一个对象
            # 确认删除
            self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()
            self.driver.find_element(By.XPATH, listPage_object_ip_address_del_yes_Button_posXpath).click()
        else:
            for id in Sou_ID_list:
                self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(id)
                self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
                self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
                time.sleep(1)
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 选择第一个对象
                # 确认删除
                self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()
                self.driver.find_element(By.XPATH, listPage_object_Keywords_del_yes_Button_posXpath).click()

    @screenshot_on_failure
    def link_many_objects(self, data, link_list_dict):
        # link简单link校验测试
        """
        :param data: link_list_dict=[{"link_dst_cluster": "42.49-User4Link", "link_dst_vsys":"Vsys2test", "url": "http://192.168.42.49/#/login","username": "admin","passwd": "admin"}])
        :param link_list_dict:
        :return:
        """
        self._just_goto_accountsPage()
        for i in range(0, 3):
            self._create(data)
        time.sleep(3)
        # 搜索创建的数据
        self._query(data)
        time.sleep(1)
        self.first_row_checkBox_element = self.driver.find_elements(By.XPATH,
                                                                    "//div[@class='el-checkbox-group']//span[@class='el-checkbox__input']")
        print(self.first_row_checkBox_element)
        sou_deatils_list = self.driver.find_elements(By.XPATH,
                                                     "//div[contains(@class,'el-table__body-wrapper')]//tr//td[count(//div[@class='el-table__header-wrapper']//span[text()='Details']/../../../preceding-sibling::th)+1]//span")
        print(sou_deatils_list)
        sou_result = []
        for detail in sou_deatils_list:
            time.sleep(1)
            sou_result.append(detail.text)
            print(sou_result)
        # 全部选中
        for checkbox in self.first_row_checkBox_element:
            checkbox.click()
            time.sleep(1)
        time.sleep(1)
        # 调用公共的link创建逻辑
        Sou_ID_list, Des_ID_list = self.objects_po.only_linkdata(link_list_dict, acc_listpage_linkButton_posId,
                                                                 acc_listpage_linkSave_posXpath,
                                                                 acc_listpage_linkAdd_posXpath,
                                                                 acc_listpage_linkOk_posXpath)
        profile_pub = ProfilesPublicOperations(self.driver)
        profile_pub.change_vsys(vsys_name="UIAutoTestVsys")
        self._just_goto_accountsPage()
        # 删除源vsys数据
        time.sleep(3)
        self._only_del_linkSouData(Sou_ID_list)
        # 删除其它目标link数据逻辑
        des_result = self._only_del_linkDstData(link_list_dict, Des_ID_list, data)
        assert des_result == sou_result

    @screenshot_on_failure
    def _only_del_linkDstData(self, link_list_dict, Des_ID_list, data):
        loginout = LogInOut(self.driver)
        loginout.logout()
        time.sleep(2)
        for link_index in range(len(link_list_dict)):
            loginout.login_other(url=link_list_dict[link_index]["url"], username=link_list_dict[link_index]["username"],
                                 passwd=link_list_dict[link_index]["passwd"])
            profile_public = ProfilesPublicOperations(self.driver)
            profile_public.change_vsys(vsys_name=link_list_dict[link_index]["link_dst_vsys"])
            self._just_goto_accountsPage()
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(data["Name"])
            self.driver.find_element(By.ID, acc_listPage_object_searchName_posId).click()
            self.driver.find_element(By.XPATH, listPage_objectSearch_ip_address_buttonSearch_posXpath).click()
            time.sleep(2)
            des_deatils_list = self.driver.find_elements(By.XPATH,
                                                         "//div[contains(@class,'el-table__body-wrapper')]//tr//td[count(//div[@class='el-table__header-wrapper']//span[text()='Details']/../../../preceding-sibling::th)+1]//span")
            des_result = []
            for detail in des_deatils_list:
                des_result.append(detail.text)
                print(des_result)
            self._just_goto_accountsPage()
            for id in Des_ID_list:
                self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(id)
                self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
                self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
                self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 选择第一个对象
                # 确认删除
                self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()
                self.driver.find_element(By.XPATH, listPage_object_Keywords_del_yes_Button_posXpath).click()

        return des_result

    def _only_del_linkSouData(self, Sou_ID_list):
        self._just_goto_accountsPage()
        for id in Sou_ID_list:
            self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(id)
            self.driver.find_element(By.ID, listPage_objectSearch_select_UUID_posXpath).click()
            self.driver.find_element(By.XPATH,listpage_search_button_posXpath).click()
            time.sleep(1)
            self.driver.find_element(By.XPATH, listPage_first_row_checkBox_posXpath).click()  # 选择第一个对象
            # 确认删除
            self.driver.find_element(By.XPATH, acc_listPage_deleteButton_posXpath).click()
            self.driver.find_element(By.XPATH, listPage_object_Keywords_del_yes_Button_posXpath).click()

    def _list_page_item_search(self, data):
        self._create(data)
        self._simple_query(data, self.random_name)
        # self.driver.implicitly_wait(3)
        time.sleep(1)
        if data["Type"] == 0:
            search_value = self._operate_item_search(self.random_account)
        else:  # =1
            pytest.skip("TSG-21808")  # todo 待修改后移除
            search_value = self.my_sub_item_name
        self.driver.find_element(By.XPATH, '(//*[@class="itemDetails cursor"]//span)[1]').click()
        self.driver.find_element(By.XPATH, listPage_item_search_text_posXpath).click()
        try:
            # 首先进行错误搜索校验
            self.driver.find_element(By.XPATH, listPage_item_search_text_posXpath).send_keys(
                self.my_random.random_number() + Keys.ENTER)
            assert self.driver.find_element(By.XPATH, listPage_item_search_total_text_posXpath).text == "Total:0"
            # 正确校验
            self.driver.find_element(By.XPATH, listPage_item_search_text_posXpath).clear()
            self.driver.find_element(By.XPATH, listPage_item_search_text_posXpath).send_keys(search_value + Keys.ENTER)
            # resulte_text = self.driver.find_element(By.XPATH,"//div[@class='IpItems list-box']//ul[@class='row-container tableList']/li[1]/div").text
            # 等待查询结果加载
            item_result_pos = '//div[@class="CommonItems list-box"]//li[@class="row el-dropdown-menu__item"] | //div[@class="CommonGroupItems list-box"]//li[@class="row el-dropdown-menu__item"]'
            self.wait.until(EC.visibility_of_element_located((By.XPATH, item_result_pos)))
            total_text = self.driver.find_element(By.XPATH,
                                                  listPage_item_search_total_text_posXpath).text
            assert total_text == "Total:1", "搜索结果错误,此时获取到的文本为{}".format(total_text)
            # self.driver.find_element(By.XPATH,"//div[@class='IpItems list-box']//span[normalize-space(text())='Close']").click()
        except Exception as e:
            raise e
        finally:
            self._just_goto_accountsPage()
            self._del(data, search_value=self.my_item_name, del_flag=1)

    def _sub_objects_drawer_search(self, data):
        self._create(data)
        self._simple_query(data, self.random_name)
        search_value = self.my_sub_item_name
        # 进入drawer_search页面
        ##勾选
        self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
        ##点击编辑按钮
        self.driver.find_element(By.XPATH, listpage_edit_button_posXpath).click()
        ##点击 add button展开drawer_search
        self.driver.find_element(By.XPATH,acc_ObjectGroupDetailPage_subObjects_addButton_normalAdd_posXpath).click()
        # drawer_search 校验
        try:
            # 首先进行错误搜索校验
            self.driver.find_element(By.XPATH, groupObjectDetailPage_addSubObjecDrawer_searchInput_posXpath).send_keys(self.my_random.random_number() + Keys.ENTER)
            assert self.driver.find_element(By.XPATH,groupObjectDetailPage_addSubObjecDrawer_totalText_posXpath).get_attribute("innerHTML") == "Total:0"
            # 正确校验
            self.driver.find_element(By.XPATH, '//i[@class="iconfont icon-Delete_X text-[16px] mt-[-1px] cursor-pointer"]').click()
            self.driver.find_element(By.XPATH, groupObjectDetailPage_addSubObjecDrawer_searchInput_posXpath).send_keys(search_value + Keys.ENTER)
            # resulte_text = self.driver.find_element(By.XPATH,"//div[@class='IpItems list-box']//ul[@class='row-container tableList']/li[1]/div").text
            # 等待查询结果加载
            item_result_pos = groupObjectDetailPage_addSubObjecDrawer_firstSubObject_posXpath
            self.wait.until(EC.visibility_of_element_located((By.XPATH, item_result_pos)))
            total_text = self.driver.find_element(By.XPATH,groupObjectDetailPage_addSubObjecDrawer_totalText_posXpath).get_attribute("innerHTML")
            assert total_text == "Total:1", "搜索结果错误,此时获取到的文本为{}".format(total_text)
            self.driver.find_element(By.XPATH, '//i[@class="iconfont icon-Clear_aNormal close-icon"]').click()
        except Exception as e:
            raise e
        finally:
            self._just_goto_accountsPage()
            self._del(data, search_value=self.my_item_name, del_flag=1)

    def _different_vsys_check(self, data):
        self._create(data)
        self.query(data)
        # 获取UIAutoTestVsys的Object信息
        self.uiAutoTestVsys_object = dict(self.objects_po.table_dict)
        print(self.uiAutoTestVsys_object)
        # 切换Vsys至Vsys0
        self.profile_pub.change_vsys(vsys_name="vsys0")
        self._create(data)
        self.query(data)
        self.vsys0_object = dict(self.objects_po.table_dict)
        self._query(data)
        time.sleep(2)
        self.view_check("vsys0")
        self.profile_pub.change_vsys(vsys_name="PerformanceTestVsys")
        self._query(data)
        time.sleep(2)
        self.view_check("PerformanceTestVsys")
        self.profile_pub.change_vsys(vsys_name="UIAutoTestVsys")
        self._query(data)
        time.sleep(2)
        self.view_check("UIAutoTestVsys")
        self.profile_pub.change_vsys(vsys_name="vsys0")
        self._del(data)

    def view_check(self, vsys_name):
        time.sleep(1)
        total = self.driver.find_element(By.XPATH, "//span[contains(text(),'Total')]").text
        count = total.split("Total:")
        if vsys_name == "PerformanceTestVsys":
            assert int(count[1]) == 1
            assert self.driver.find_element(By.XPATH, listPage_First_object_ID_posXpath).text == self.vsys0_object["UUID"]
        elif vsys_name == "vsys0":
            assert int(count[1]) == 1
            assert self.driver.find_element(By.XPATH, listPage_First_object_ID_posXpath).text == self.vsys0_object["UUID"]
            # assert self.driver.find_element(By.XPATH, listPage_Second_object_ID_posXpath).text == self.uiAutoTestVsys_object["ID"]
            # self.driver.find_element(By.XPATH,"//*[@id='ly-table1-listcontent']//tbody/tr[2]//span[@class='el-checkbox__inner']").click()
            # self.driver.find_element(By.XPATH,"//button[@id='appEdit-_OperateBtns_ElRow_Objects_port_Home_App_anonymousComponent']//p[normalize-space(text()) = 'View']").click()
            # assert len(self.driver.find_elements(By.XPATH, '//div[@class="IconBtn disabled-btn"]')) == 3
            # self.driver.isElementExist(port_ObjectDetailPage_mainOkButton_posXpath)
            # assert  self.driver.Exist == False
            # self.driver.find_element(By.XPATH,port_ObjectPage_button_cancel_posXpath).click()
        elif vsys_name == "UIAutoTestVsys":
            assert int(count[1]) == 2
            assert self.driver.find_element(By.XPATH, listPage_First_object_ID_posXpath).text == self.vsys0_object["UUID"]
            assert self.driver.find_element(By.XPATH, listPage_Second_object_ID_posXpath).text == self.uiAutoTestVsys_object["UUID"]
            self.driver.find_element(By.XPATH, listPage_select_first_object_posXpath).click()
            self.driver.find_element(By.XPATH, listPage_view_button_posXpath).click()
            # add_item_disable = self.driver.element_isExist(by=By.XPATH,value="//div[@class='object-item-add']/div[@class='IconBtn disabled-btn']")
            # edit_item_disable = self.driver.element_isExist(by=By.XPATH,value="//div[@class='list-container']//div[@class='IconBtn disabled-btn'][1]")
            # del_item_disable = self.driver.element_isExist(by=By.XPATH,value="//div[@class='list-container']//div[@class='IconBtn disabled-btn'][2]")
            # assert add_item_disable == edit_item_disable == del_item_disable == True
            self.driver.isElementExist(port_ObjectDetailPage_mainOkButton_posXpath)
            assert self.driver.Exist == False
            self.driver.find_element(By.XPATH, port_ObjectPage_button_cancel_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_select_second_object_posXpath).click()
            self.driver.find_element(By.XPATH, listpage_delete_button_posXpath).click()
            self.driver.find_element(By.XPATH, port_listPage_deleteYes_posXpath).click()

    def _audit_log_all_operation(self, data):
        self._create(data)
        try:
            self._simple_query(data, search_value=self.my_item_name)
            self._modify(data)
            data['Items'] = ["->[random]"]
            self._simple_query(data, search_value=self.my_item_name)
            self._modify(data)
            # 导出
            self._export_objects()
        except Exception as e:
            raise e
        finally:
            self._del(data)
        self.objects_po.audit_log_view("Account")

    def _multiple_search(self, data):
        search_type_list = data["Search type"].split('&')
        try:
            self._create(data)
            # 获取页面元素
            self._just_goto_accountsPage()
            my_table_dict = self.objects_po.extract_ele()
            for search_type in search_type_list:
                if search_type == "UUID":
                    self.driver.find_element(By.XPATH,listpage_search_box_posXpath).click()
                    self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(
                        my_table_dict['UUID'])
                    self.driver.find_element(By.XPATH, listPage_objectSearch_select_UUID_posXpath).click()
                elif search_type == "Name":
                    self.driver.find_element(By.XPATH,listpage_search_box_posXpath).click()
                    input_value = self.operate_input_value_4_multiple_search(my_table_dict['Name'])
                    self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(input_value)
                    self.driver.find_element(By.ID, acc_listPage_object_searchName_posId).click()
                elif search_type == "Description":
                    self.driver.find_element(By.XPATH,listpage_search_box_posXpath).click()
                    input_value = self.operate_input_value_4_multiple_search(my_table_dict['Description'])
                    self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(input_value)
                    self.driver.find_element(By.ID, acc_listPage_object_searchDescription_posId).click()
                # elif search_type == "Details":
                #     self.driver.find_element(By.XPATH,listpage_search_box_posXpath).click()
                #     input_value = self.operate_input_value_4_multiple_search(details_first_value)
                #     self.driver.find_element(By.XPATH,listpage_search_box_posXpath).send_keys(input_value)
                #     self.driver.find_element(By.ID, acc_listPage_object_searchDetails_posId).click()
            search_button = self.driver.find_element(By.XPATH,listpage_search_button_posXpath)
            self.driver.execute_script("arguments[0].scrollIntoView();", search_button)
            search_button.click()
        except Exception as e:
            raise e
        finally:
            # 清理测试数据
            self._del(data)

    def operate_input_value_4_multiple_search(self, input_value):
        full_or_part_flag = random.randint(0, 1)
        if full_or_part_flag == 0:
            input_value = input_value
        else:
            input_value = input_value[0:random.randint(min(5, len(input_value)), len(input_value))]
        return input_value

    create = _create
    query = _query
    delete = _del
    go_to_page = _just_goto_accountsPage


if __name__ == '__main__':
    # # driver1
    # driver = download_files()
    # acc = Accounts(driver)

    # driver2
    chrome_option = webdriver.ChromeOptions()
    driver = MyWebDriver(
        # command_executor="http://192.168.64.11:4444",
        # command_executor="http://192.168.38.144:4444",
        command_executor="http://localhost:4444/wd/hub",
        options=chrome_option
    )
    acc = Accounts(demo_fixture=driver)
    driver.implicitly_wait(5)

    driver.get("http://192.168.44.72")
    # driver.get("http://192.168.42.49")
    driver.maximize_window()
    driver.find_element(By.XPATH, '//input[@placeholder="User name"]').send_keys("guouitest")
    driver.find_element(By.XPATH, '//input[@placeholder="Password"]').send_keys("jMIfnvhc1U")
    driver.find_element(By.XPATH, '//button[@class="MuiButtonBase-root MuiButton-root MuiLoadingButton-root MuiButton-contained MuiButton-containedPrimary MuiButton-sizeLarge MuiButton-containedSizeLarge MuiButton-colorPrimary MuiButton-root MuiLoadingButton-root MuiButton-contained MuiButton-containedPrimary MuiButton-sizeLarge MuiButton-containedSizeLarge MuiButton-colorPrimary !bg-[#4487d4] css-zeizzp"]').click()
    # 切换Vsys
    # profile_pub = ProfilesPublicOperations(driver)
    # profile_pub.change_vsys(vsys_name='UIAutoTestVsys')
    acc._different_vsys_check(data=
    {
        "ids": "test_different_vsys_check",
        "Model": "create",
        "Type": 0,
        "Search type": "Name",
        "Name": "",
        "Items": [
            "^skkj$"
        ],
        "Description": ""
    }
    )
    time.sleep(3)
    driver.quit()