web底层事件操作

# coding: utf-8
# Author：xxx
# Date ：xxx

from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
from selenium.webdriver import ActionChains
from selenium import webdriver
import datetime
import time
import os
import re

from pages.loginPage import LOGIN
from pages.indexPage import *
from commom.logger import Log

logger = Log()


class WebBases(object):

    def __init__(self):
        # 初始化driver，打开google浏览器
        self.driver = webdriver.Chrome()
        logger.info("初始化google浏览器")
        # 设置隐性等待10s
        self.driver.implicitly_wait(10)
        # 设置web界面最大化
        self.driver.maximize_window()
        logger.info("打开google浏览器完成")

    def aw_open_web(self, url):
        """
        # 输入URL
        # 入参：输入页面的url
        """
        try:
            self.driver.get(url)
            logger.info("在浏览器中输入URL：{} ".format(url))
            time.sleep(3)
        except:
            self.aw_save_screenshot()
            raise Exception("can't open google web ...")

    def aw_refresh_web(self):
        # 功能：刷新网页
        self.driver.refresh()
        logger.info("刷新google浏览器完成")

    def aw_switch_system_role(self, role):
        """
        # 登录系统后，切换组织层级
        # role: 组织
        """
        try:
            self.aw_click_element(By.CLASS_NAME, INDEX.ROLE_SWITCH)
            time.sleep(1)
            self.aw_click_element(By.ID, INDEX.SEARCH_ROLE)
            time.sleep(1)
            self.aw_clear_set_input(By.CLASS_NAME, INDEX.SEARCH_FIELD, role)
            es = self.driver.find_elements(By.XPATH, INDEX.SEARCH_RESULT)
            e_list = [e.text.split('】')[1].strip() for e in es]
            logger.info(e_list)
            num = e_list.index(role)
            self.driver.find_element_by_xpath(INDEX.SEARCH_RESULT + str([num+1])).click()
            logger.info("切换系统组织完成")
            time.sleep(5)
        except:
            raise Exception("切换系统组织失败")

    def aw_side_switch(self, name):
        # 兼任切换
        logger.info(name)
        e = self.driver.find_element_by_xpath('//*[@id="Hui-userbar"]/ul/li[4]/a[contains(text(),"兼任切换")]')
        ActionChains(self.driver).click(e).perform()
        es = self.driver.find_elements_by_xpath('//*[@id="Hui-userbar"]/ul/li[4]/ul/li/a')
        names = [e.text for e in es]
        for n in names:
            if name in n:
                e = self.driver.find_element_by_xpath(f'//*[@id="Hui-userbar"]/ul/li[4]/ul/li/a[contains(text(), "{name}")]')
                e.click()
                time.sleep(1)
                self.aw_refresh_web()

    def aw_save_screenshot(self):
        """
        # 功能：自动截图
        # 指定截图的文件名
        """
        now = datetime.datetime.now().strftime('%Y-%m-%d_%H_%M_%S')
        filename = now + "_pic.png"
        dayTime = datetime.datetime.now().strftime('%Y-%m-%d')
        # 指定picture文件存放位置，按照日前格式划分文件夹
        pic_dir = r"D:/workspace/SPMAutoTest/pic/{}/".format(dayTime)
        # 判断文件夹是否已存在
        isExists = os.path.exists(pic_dir)
        if not isExists:
            os.makedirs(pic_dir)
        self.driver.get_screenshot_as_file(pic_dir + filename)

    def aw_login_sys(self, tel, pwd):
        """
        # 登录系统
        # 入参：ID tel，密码pwd，域名domain
        """
        # 检查元素是否存在
        self.aw_check_element_visible(LOGIN.SUB)
        time.sleep(1)
        self.aw_clear_input(By.ID, LOGIN.ID)
        self.aw_send_keys_input(By.ID, LOGIN.ID, tel)
        time.sleep(1)
        self.aw_clear_input(By.ID, LOGIN.PWD)
        self.aw_send_keys_input(By.ID, LOGIN.PWD, pwd)
        time.sleep(1)
        self.aw_click_element(By.ID, LOGIN.SUB)
        time.sleep(1)
        self.aw_check_login_success()
        logger.info("登录SPM系统完成")

    def aw_logout_sys(self):
        """
        # 点击退出，退出系统
        """
        time.sleep(1)
        self.driver.find_element_by_id(INDEX.LOGOUT).click()
        time.sleep(1)
        self.aw_click_element(By.CLASS_NAME, 'layui-layer-btn0')
        time.sleep(1)
        logger.info("点击退出按钮，退出登录")

    def aw_close_web(self):
        try:
            # 关闭网页
            self.driver.close()
            time.sleep(1)
            # 退出浏览器
            self.driver.quit()
            logger.info("关闭google浏览器完成")
        except:
            self.aw_save_screenshot()
            raise Exception("can't close google web ...")

    def aw_web_navigate(self, first_menu=None, second_menu=None, third_menu=None):
        """
        # 功能：实现web系统三级菜单依次展开，进行子系统的相关操作
        # 参数：一级菜单：first_menu, 二级菜单：second_menu，三级菜单：third_menu
        """
        try:
            # self.aw_click_by_text("首页")
            if first_menu:
                self.aw_click_element(By.XPATH, f'/html/body/aside/div/dl/dt[contains(text(), "{first_menu}")]')
                logger.info("进入一级菜单 {}".format(first_menu))
                time.sleep(2)

            if second_menu:
                self.aw_click_element(By.XPATH, f'//*/dd/ul/li/a[contains(text(), "{second_menu}")]')
                logger.info("进入二级菜单 {}".format(second_menu))
                time.sleep(2)

            if third_menu:
                self.aw_click_element(By.XPATH, f'//*/ul/li/section/a[contains(text(), "{third_menu}")]')
                logger.info("进入三级菜单 {}".format(third_menu))
                time.sleep(2)
        except:
            raise Exception("系统三级菜单跳转异常")
            
    def aw_check_login_success(self):
        """
        # 检查是否登录成功
        """
        try:
            self.aw_check_element_visible(INDEX.LOGOUT)
            logger.info("确认已经进入SPM系统")
            time.sleep(2)
        except:
            self.aw_save_screenshot()
            raise Exception("user not login success ...")

    def aw_check_element_visible(self, value, by=By.ID):
        """
         # 检查元素是否存在
         # 传入value，是元素的值（id）
        """
        flag = True
        try:
            WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((by, value)))
            logger.info("{} 元素在UI中存在".format(value))
            self.driver.find_element_by_id(value)
            return flag
        except:
            flag = False
            logger.warn("{} 元素在UI中不存在".format(value))
            self.aw_save_screenshot()
            raise Exception("元素 {} 不可见... {}".format(value, flag))

    def aw_is_element_present(self, by, locator):
        """
        # 判断某个元素是否出现
        :param by:     by的参数可选，by=By.ID(By.Xpath,By.Name)
        :param locator:  value值根据对应的by，填写html中id，xpath，name
        """
        try:
            WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((by, locator)))
            self.driver.find_element(by, locator)
            logger.info("元素 {} 在界面中存在".format(locator))
            return True
        except:
            logger.warn("********   can not find this element   ********")
            self.aw_save_screenshot()
            raise Exception("NoSuchElementException: {}=={}".format(by, locator))

    def aw_click_element(self, by, locator):
        """
        # 功能：点击元素
        # by，查找元素的方式，By.ID,By.Xpath等
        # locator，id，xpath等
        """
        self.aw_is_element_present(by, locator)
        time.sleep(0.5)
        self.driver.find_element(by, locator).click()
        logger.info("点击存在 {} 元素完成".format(locator))

    def aw_clear_input(self, by, locator):
        """
        # 清除input框中的内容
        # by，查找元素的方式，By.ID,By.Xpath等
        # locator，id，xpath等
        """
        try:
            self.driver.find_element(by, locator).clear()
            logger.info("input {} 的内容被清除".format(locator))
        except:
            self.aw_save_screenshot()
            raise Exception("未找到元素 {} ".format(locator))

    def aw_send_keys_input(self, by, locator, text):
        """
        # 在input框中输入内容
        :param by: 查找元素的方式，By.ID,By.Xpath等
        :param locator: value，id，xpath等
        :param text: 输入的内容
        """
        try:
            self.driver.find_element(by, locator).send_keys(text)
            logger.info("在元素 {} 处填写内容 {} ".format(locator, text))
        except:
            self.aw_save_screenshot()
            raise Exception("未找到元素 {}".format(locator))

    def aw_clear_set_input(self, by, locator, text):
        """
        # 输入框中，先清除，在填入
        :param by:  定位元素方式
        :param locator: 元素位置
        :param text:    填入值
        :return:
        """
        self.aw_click_element(by, locator)
        self.aw_clear_input(by, locator)
        time.sleep(1)
        self.aw_send_keys_input(by, locator, text)

    def aw_checkbox_switch(self, switch, by, locator):
        """
        # 功能：checkbox选中或者反选
        # 入参switch：on选中，off去选
        """
        if switch == "on":  # 要求选中
            # 检查选中状态
            flag = self.driver.find_element(by, locator).is_selected()
            logger.info("flag: {}".format(flag))
            if flag:  # 选中状态
                logger.info("这个checkbox已经被选中")
            else:  # 未选中，点击选择
                self.driver.find_element(by, locator).click()
                logger.info("checkbox选中完成")

        elif switch == "off":  # 要求去选
            # 检查选中状态
            flag = self.driver.find_element(by, locator).is_selected()
            if flag:  # True，选中
                self.driver.find_element(by, locator).click()  # 去选
                logger.info("这个checkbox去勾选完成")
            else:  # 已经为未选中
                logger.info("这个checkbox已经去勾选")

    def aw_check_checkbox_states(self, by, locator):
        """
        # checkbox选中的状态
        # by，查找元素的方式，By.ID,By.Xpath等
        # locator，id，xpath等
        """
        try:
            flag = self.driver.find_element(by, locator).is_selected()
            logger.info("{} checkbox status is {}".format(locator, flag))
            return flag
        except:
            self.aw_save_screenshot()
            raise Exception("未找到元素 {}".format(locator))

    def aw_select_by_text(self, by, locator, text):
        """
        # 下拉框
        # 功能：对于标签是select的下拉框，选择相应的选项
        # 入参：根据value值，来选择选项
        :param by:  定位元素方式
        :param locator: 元素位置
        :param text:    填入值
        """
        try:
            element = self.driver.find_element(by, locator)
            time.sleep(1)
            Select(element).select_by_visible_text(text)
            logger.info(f"列表中 {text} 已经选中")
            return True
        except:
            self.aw_save_screenshot()
            raise Exception("没有找到可以选择的值")

    def aw_select_by_value(self, by, locator, value):
        """
        # 下拉框
        # 功能：对于标签是select的下拉框，选择相应的选项
        # 入参：根据value值，来选择选项
        :param by:  定位元素方式
        :param locator: 元素位置
        :param value:  填入值
        """
        try:
            element = self.driver.find_element(by, locator)
            # logger.info(element)
            time.sleep(1)
            Select(element).select_by_value(value)
            logger.info("这个下拉列表已经选中")
        except:
            self.aw_save_screenshot()
            raise Exception("没有找到可以选择的值")

    def aw_select_by_index(self, by, locator, number):
        """
        # 下拉框
        # 功能：对于标签是select的下拉框，选择相应的选项
        # 入参：根据value值，来选择选项
        """
        try:
            element = self.driver.find_element(by, locator)
            time.sleep(1)
            Select(element).select_by_index(number)
            logger.info("这个下拉列表已经选中")
        except:
            self.aw_save_screenshot()
            raise Exception("填入下标越界")

    def aw_deselect_select(self, by, locator):
        """
        # 下拉框，取消所有选中的option
        :return:
        """
        try:
            s = self.driver.find_element(by, locator)
            Select(s).deselect_all()
            logger.info("这个下拉列表去选")
        except:
            self.aw_save_screenshot()
            raise Exception("填入下标越界")

    def aw_find_by_text(self, by, locator, text):
        """
        # 功能：非select 下拉菜单选择
        # 需要通过二次点击，选择相应的值
        """
        # 第一次点击，弹出选择菜单
        self.aw_click_element(by, locator)
        logger.info("第一次通过{}将选择列表弹出".format(locator))
        # 第二次点击，选择对应的值
        self.driver.find_element_by_xpath('//ul/li[contains(text(), "{}")]'.format(text)).click()
        logger.info("第二次选择: {}".format(text))

    def aw_search_by_text(self, text):
        """
        # 通过text查找定位元素
        """
        self.driver.find_element_by_xpath("//*[contains(text(), '{}')]".format(text)).click()

    def aw_click_by_text(self, value):
        # 点击通过text的定位
        # 通过text定位，父标签是a标签
        try:
            e = self.driver.find_element_by_link_text(value)
            logger.info("通过text {} 定位到元素".format(value))
            e.click()
            logger.info("text {} 定位元素点击完成".format(value))
        except:
            raise Exception("通过text {} 未定位到元素".format(value))

    def aw_find_values(self, by, locator):
        """
        # 根据元素找到多个元素
        # by，查找元素的方式，By.ID,By.Xpath等
        # value，id，xpath等
        """
        es = self.driver.find_elements(by, locator)
        return es

    def aw_switch_to_frame(self, num=0):
        # 在html中，切入到iframe中
        try:
            iframe = self.driver.find_elements_by_tag_name('iframe')[num]
            self.driver.switch_to.frame(iframe)
            logger.info("已经切入到frame中")
        except:
            raise Exception("切入frame失败")

    def aw_switch_to_parent(self):
        # 回退到父级iframe
        try:
            self.driver.switch_to.parent_frame()
            logger.info("已经退出iframe")
        except:
            raise Exception("退出frame失败")

    def aw_switch_to_default_content(self):
        # 退出iframe
        try:
            self.driver.switch_to.default_content()
            logger.info("已经退出iframe")
        except:
            raise Exception("退出frame失败")

    def aw_get_ele_text(self, by, path):
        # 获取元素的text
        text = self.driver.find_element(by, path).text
        return text

    def aw_os_send_path(self, path):
        # 遇到弹框，写入文件路径方法
        # path: 文件的路径
        time.sleep(3)
        os.system(path)
        time.sleep(3)

    def aw_get_right_page(self):
        # 分页格式：1 2 3… 5到第 1 页 确定，共 45 条 ,10 条/页
        # 返回数据：45
        pages = self.driver.find_element_by_class_name('layui-laypage-count').text
        pages = int(re.findall(r"\d+", pages)[0])
        logger.info(pages)
        return pages

    def aw_get_left_page(self):
        # 分页格式：显示 1 到 10 ，共 82 条；
        #          第 1 到 8 ，共 8 条
        # 返回数据：82
        try:
            WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'dataTables_info')))
            pages = self.driver.find_element_by_class_name('dataTables_info').text.split("共")[1]
            pages = int(re.findall(r"\d+", pages)[0].strip())
            logger.info(pages)
            return pages
        except:
            pages = 0
            return pages

    def aw_get_ant_page(self):
        # 分页格式：这是在iframe页面中，共 31 条，1，2，3，10条/页
        # 返回数据：31  vue
        p = self.driver.find_element_by_class_name('ant-pagination-total-text').text
        pages = int(re.findall(r"\d+", p)[0])
        if pages > 10:
            self.aw_click_element(By.CSS_SELECTOR, 'div.ant-select-selection__rendered > div > span')
            time.sleep(1)
            self.aw_click_element(By.CSS_SELECTOR, 'div.ant-select-dropdown-content > ul > li:nth-child(4)')
        return pages

    def aw_display_title_num(self, num):
        # 选择显示的页数，10，20...在table的下面
        # num: 是指显示条目数
        try:
            self.aw_click_element(By.XPATH, '//*/span[@class="layui-laypage-limits"]/select')
            time.sleep(3)
            self.aw_click_element(By.XPATH, f'//*/span[@class="layui-laypage-limits"]/select/option[@value="{num}"]')
            time.sleep(3)
            return True
        except:
            return False

    def aw_select_list_info(self, value=None, loc=None, xpath=None):
        """
        # 下拉选择中，搜索框是弹出框。 class: "select2-search__field"
        :param value: 输入值
        :param loc: 选择位置
        :param xpath: 结果路径
        :return:
        """
        time.sleep(1)
        self.aw_click_element(By.ID, loc)  # 点击输入
        self.aw_send_keys_input(By.CLASS_NAME, INDEX.SEARCH_FIELD, value)   # 输入值
        time.sleep(1)
        es = self.driver.find_elements(By.XPATH, xpath)  # 匹配找到所有的项
        e_list = [e.text.strip() for e in es]
        # logger.info(e_list)
        num = 0   # 在项目中的下标
        for e in e_list:
            if value in e:
                num = e_list.index(e)
        self.driver.find_element_by_xpath(xpath + str([num + 1])).click()

    def aw_select_from_list(self, value1, value2):
        # 这个方法是对 vue 页面下拉列表list选择 vue
        try:
            self.aw_click_element(By.XPATH, f'//*[contains(text(), "{value1}")]')
            time.sleep(3)
            self.aw_click_element(By.XPATH, f'//ul/li[contains(text(), "{value2}")]')
        except:
            raise Exception("可选项选择失败")

    def aw_find_by_preceding_text(self, value, num):
        # 通过text定位
        # 根据弟弟标签去过去哥哥的标签  /parent::*/preceding-sibling::td[1]
        e = self.driver.find_element_by_xpath("//*[contains(text(), '{}')]/preceding-sibling::td[{}]".format(value, num))
        logger.info("通过text {} 定位到元素".format(value))
        return e

    def aw_find_by_following_text(self, value, num):
        # 通过text定位
        # 根据哥哥标签去过去弟弟的标签  /parent::*/following-sibling::td[1]
        e = self.driver.find_element_by_xpath("//*[contains(text(), '{}')]/following-sibling::td[{}]".format(value, num))
        logger.info("通过text {} 定位到元素".format(value))
        return e

    def aw_close_X(self):
        # 点击关闭
        jq = "$('span.layui-layer-setwin > a').click()"
        self.driver.execute_script(jq)

    def aw_get_tip_info(self, expect=None):
        # 获取提示消息
        try:
            time.sleep(0.3)
            tip = self.driver.find_element_by_css_selector('div.layui-layer-content').text
            logger.info("page alert 弹出消息 ....")
            logger.info(tip)
            if expect in tip:
                return True
            else:
                return False
        except:
            raise Exception("没有找到弹出消息")

    def aw_double_click_element(self, locator, value):
        self.driver.find_element_by_xpath(f'//select[@id={locator}]/option[contains(text(), "{value}")]').click()