def normal_flash_card_operate(self, stu_id, book_id, *, word_info, is_enhanced=True):
"""正常闪卡游戏过程"""
print('======= 正常闪卡游戏 ======= \n')
word_list = []
begin_time = round(time.time())
while self.wait_check_sentence_explain_page():
_, _, word_id = self.game_container()
word = self.normal_flash_word()
word_type = '短语' if ' ' in word else '单词'
if word in word_list:
self.base_assert.except_error('单词已存在， 单词未去重')
word_list.append(word)
explain = self.word_explain()
sentence = self.sentence()
sentence_explain = self.sentence_explain()
print('单词：' + word,
'解释：' + explain,
'句子：' + sentence,
'句子解释：' + sentence_explain,
sep='\n')
word_info[word_id] = (word, explain, word_type)
if is_enhanced:
db_all_explain = WordBookSqlHandle().get_student_explain_list_by_word_id(stu_id, book_id, word_id)
print('查询到的单词解释：', db_all_explain)
print('解释分割：', explain.split('；'))
if db_all_explain != explain.split('；'):
self.base_assert.except_error('题目解释不是已学解释合并')
self.commit_btn().click()
print('-'*30, '\n')
time.sleep(1)
spend_seconds = round(time.time()) - begin_time
return spend_seconds
def check_recite_word_fluency_operate(self,
stu_id,
book_id,
before_word_fluency,
wrong_word_list=None,
fl_change=False):
"""复习单词F值校验"""
explain_fluency_info = {}
for x in before_word_fluency:
explain_info = before_word_fluency[x]
explain_fluency_info.update(explain_info)
self.check_words_fluency_value(stu_id,
explain_fluency_info,
f_is_change=fl_change)
if wrong_word_list:
pro_path = os.path.abspath('.')
with open(pro_path + '\\app\\wordbook\\test_data\\wrong.json',
'r') as f:
note_dict = json.load(f)
already_study_word_info = {
x: WordBookSqlHandle().get_student_explain_list_by_word_id(
stu_id, book_id, x)
for x in wrong_word_list
}
note_dict.update(already_study_word_info)
with open(pro_path + '\\app\\wordbook\\test_data\\wrong.json',
'w') as f:
f.write(json.dumps(note_dict, ensure_ascii=False))
f.close()
def error_note_restore_word_operate(self,
stu_id,
book_id,
wrong_id_list,
second_wrong_words,
wrong_count=None,
do_right=False):
"""错题本中还原单词操作"""
print('===== 错题本中的还原单词操作 =====\n')
wrong_word_id, index = 0, 0
while self.wait_check_restore_word_page():
self.click_speaker_icon()
self.commit_btn_judge()
word_id = self.game_container()[-1]
wrong_id_list.append(word_id)
explain = self.restore_word_explain()
answer_word = WordBookSqlHandle().get_word_by_word_id(word_id)
print('单词id：', word_id)
print('单词解释：', explain)
print('正确答案：', answer_word)
db_all_explain = WordBookSqlHandle(
).get_student_explain_list_by_word_id(stu_id, book_id, word_id)
if explain.split('；') != db_all_explain:
self.base_assert.except_error('题目解释不是已学解释合并')
if not do_right:
if index == 0:
wrong_word_id = word_id
second_wrong_words.append(wrong_word_id)
if word_id in second_wrong_words:
self.restore_do_wrong_operate(answer_word)
self.commit_btn().click()
wrong_count[0] += 1
else:
self.restore_do_right_operate(answer_word)
else:
self.restore_do_right_operate(answer_word)
mine_answer = self.finish_word()
print('我的答案：', mine_answer)
self.commit_btn().click()
time.sleep(2)
index += 1
print('-' * 30, '\n')
def error_note_spell_game_operate(self,
stu_id,
book_id,
second_wrong_words,
wrong_count=None,
do_right=False):
"""本书易错词单词拼写游戏处理"""
index = 0
while self.wait_check_spell_page():
_, _, word_id = self.game_container()
print('默写单词id：', word_id)
explain = self.word_explain()
print('默写解释：', explain)
right_word = WordBookSqlHandle().get_word_by_word_id(word_id)
db_all_explain = WordBookSqlHandle(
).get_student_explain_list_by_word_id(stu_id, book_id, word_id)
if explain.split('；') != db_all_explain:
self.base_assert.except_error('题目解释不是已学解释合并')
if index == 0:
second_wrong_words[0] = word_id
if not do_right:
if word_id == second_wrong_words[0]:
self.spell_game_process(word_id)
wrong_count[1] += 1
else:
self.spell_game_process(word_id,
do_right=True,
right_answer=right_word)
else:
self.spell_game_process(word_id,
do_right=True,
right_answer=right_word)
if word_id == second_wrong_words[0]:
self.commit_btn().click()
time.sleep(1)
index += 1
if wrong_count[1] == 4:
self.flash_copy.flash_copy_operate(second_wrong_words[0])
wrong_count[1] = 0
print('~' * 20, '\n')
def check_new_word_fluency_operate(self, stu_id, book_id, before_word_fluency, before_phrase_fluency, fl_change):
"""
新词F值查看主要步骤
:param stu_id: 学生id
:param book_id: 图书id
:param before_word_fluency: 学前单词熟练度
:param before_phrase_fluency: 学前短语熟练度
:param fl_change: 是否发生F值变化
:return:
"""
wrong_word_fluency = {}
right_word_fluency = {}
if before_word_fluency:
end_index = 1 if len(before_word_fluency) == 1 else 2
wrong_word_fluency.update(self.slice.dict_slice(before_word_fluency, end=end_index))
right_word_fluency.update(self.slice.dict_slice(before_word_fluency, start=end_index))
if len(before_phrase_fluency):
wrong_word_fluency.update(self.slice.dict_slice(before_phrase_fluency, end=1))
right_word_fluency.update(self.slice.dict_slice(before_phrase_fluency, start=1))
self.check_words_fluency_value(stu_id, wrong_word_fluency, f_is_change=fl_change)
self.check_words_fluency_value(stu_id, right_word_fluency, f_is_change=fl_change, is_right=True)
# 将错题写入错题记录文件
if wrong_word_fluency:
pro_path = os.path.abspath('.')
with open(pro_path + '\\app\\wordbook\\test_data\\wrong.json', 'r') as f:
note_dict = json.load(f)
explain_id_list = list(wrong_word_fluency.keys())
word_id_list = [WordBookSqlHandle().get_word_id_by_explain_id(stu_id, x) for x in explain_id_list]
already_study_word_info = {x: WordBookSqlHandle().get_student_explain_list_by_word_id(stu_id, book_id, x)
for x in word_id_list}
note_dict.update(already_study_word_info)
with open(pro_path + '\\app\\wordbook\\test_data\\wrong.json', 'w') as f:
f.write(json.dumps(note_dict, ensure_ascii=False))
f.close()
def check_words_fluency_value(self, stu_id, before_fluency, f_is_change, is_right=False):
"""
校验单词解释的F值是否正确
:param stu_id 学生id
:param before_fluency 做题之前单词F值列表
:param is_right 是否做对
:param f_is_change F值是否变换
"""
print('F值是否发生变化：', f_is_change)
after_fluency = {x: WordBookSqlHandle().get_explain_fluency_by_explain_id(stu_id, x) for x in list(before_fluency.keys())}
print('学前单词F值:', before_fluency)
print('学后单词F值:', after_fluency)
if f_is_change:
add_value = 2 if is_right else 1
else:
add_value = 0
check_fluency_info = {x: before_fluency[x] + add_value for x in list(before_fluency.keys())}
if check_fluency_info != after_fluency:
self.base_assert.except_error('单词的F值变化有误， 应为{}, 实际为{}'.format(check_fluency_info, after_fluency))
def __init__(self):
self.sql = WordBookSqlHandle()
def __init__(self):
self.home = WordHomePage()
self.data = WordBookSqlHandle()
self.vocab = WordChoice()
self.listen_spell = ListenSpell()
self.spell = WordSpell()
class ExamPage(WordBookPublicElePage):
def __init__(self):
self.home = WordHomePage()
self.data = WordBookSqlHandle()
self.vocab = WordChoice()
self.listen_spell = ListenSpell()
self.spell = WordSpell()
@teststep
def wait_check_exam_bank_type_page(self):
"""选择测试题型页面检查点"""
locator = (By.CSS_SELECTOR, ".el-checkbox-group")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_exam_type_page(self):
"""选择测试题型页面检查点"""
time.sleep(2)
locator = (By.CSS_SELECTOR, ".word-centent")
return self.wait.wait_check_element(locator)
@teststep
def wait_check_answer_card_page(self):
"""答题卡页面检查点"""
time.sleep(2)
locator = (By.CSS_SELECTOR, ".answer-card")
return self.wait.wait_check_element(locator)
@teststep
def tab_content(self):
"""页面内容"""
locator = (By.CSS_SELECTOR, ".word-centent")
return self.wait.wait_find_element(locator).text
@teststep
def exam_labels(self):
"""今日已学单词个数"""
locator = (By.CSS_SELECTOR, ".el-radio-group .el-radio")
return self.wait.wait_find_elements(locator)
@teststep
def label_buttons(self):
"""测试类型按钮"""
locator = (By.CSS_SELECTOR, ".btn-control .el-button")
return self.wait.wait_find_elements(locator)
@teststep
def online_test_btn(self):
"""在线测试"""
locator = (By.CSS_SELECTOR, ".btn-control .el-button:first-child")
return self.wait.wait_find_element(locator)
@teststep
def unit_listening_btn(self):
"""单元听写"""
locator = (By.CSS_SELECTOR, ".btn-control .el-button:nth-child(4)")
return self.wait.wait_find_element(locator)
@teststep
def bank_type_checkbox(self):
"""题型选项"""
locator = (By.CSS_SELECTOR, ".el-checkbox-group .el-checkbox")
return self.wait.wait_find_elements(locator)
@teststep
def previous_btn(self):
"""上一题按钮"""
locator = (By.CSS_SELECTOR, ".icons .icon-arrow-left")
return self.wait.wait_find_element(locator)
@teststep
def check_detail_btn(self):
"""点击查看选题页面"""
locator = (By.CSS_SELECTOR, ".icons .icon-card")
self.wait.wait_find_element(locator).click()
@teststep
def answer_card_tip_content(self):
"""答题卡页面提示内容"""
locator = (By.CSS_SELECTOR, ".answer-card h3")
return self.wait.wait_find_element(locator).text
@teststep
def next_btn(self):
"""下一题按钮"""
locator = (By.CSS_SELECTOR, ".icons .icon-arrow-right")
return self.wait.wait_find_element(locator)
@teststep
def bank_number(self):
"""题号列表"""
locator = (By.CSS_SELECTOR, ".detail .number")
return self.wait.wait_find_elements(locator)
@teststep
def click_carry_out_btn(self):
"""点击交卷按钮"""
locator = (By.CSS_SELECTOR, ".control .el-button")
self.wait.wait_find_element(locator).click()
@teststep
def exam_name(self):
"""试卷名称"""
locator = (By.CSS_SELECTOR, ".exam-title")
return self.wait.wait_find_element(locator).text
@teststep
def score(self):
"""得分"""
locator = (By.CSS_SELECTOR, ".score")
ele = self.wait.wait_find_element(locator)
return int(ele.text)
@teststep
def get_all_item(self):
locator = (By.CSS_SELECTOR, ".table-body .item")
return self.wait.wait_find_elements(locator)
@teststep
def word_index(self, item_ele):
"""单词索引"""
ele = item_ele.find_element_by_css_selector('div:first-child')
return ele.text
@teststep
def word_speaker(self, item_ele):
"""单词喇叭播放按钮"""
ele = item_ele.find_element_by_css_selector('.text-wrap i')
return ele
@teststep
def result_words(self, item_ele):
"""结果页单词"""
ele = item_ele.find_element_by_css_selector('.text-wrap span')
return ele.text
@teststep
def result_word_explain(self, item_ele):
"""单词解释"""
ele = item_ele.find_element_by_css_selector('.el-tooltip span')
return ele.text
@teststep
def word_game_type(self, item_ele):
"""单词所属游戏类型"""
ele = item_ele.find_element_by_css_selector('div:nth-child(4)')
return ele.text
@teststep
def vocab_select_icon(self, item_ele):
"""词汇选择正确和错误标识"""
ele = item_ele.find_element_by_css_selector('div:nth-child(5)> i')
return ele
@teststep
def spell_icon(self, item_ele):
"""单词拼写正确和错误标识"""
ele = item_ele.find_element_by_css_selector('div:nth-child(5)> span')
return ele
@teststep
def vocab_select_answer_word(self):
"""一测到底答案"""
locator = (By.CSS_SELECTOR, '.word')
return self.wait.wait_find_element(locator).text
@teststep
def listen_spell_game_containers(self):
"""单词听写父级容器"""
locator = (By.CSS_SELECTOR, '.dctx-container')
return self.wait.wait_find_elements(locator).text
@teststep
def vocab_select_game_container(self):
"""词汇选择父级容器"""
locator = (By.CSS_SELECTOR, '.chxz-container')
return self.wait.wait_find_elements(locator)
@teststep
def spell_word_game_container(self):
"""单词拼写父级容器"""
locator = (By.CSS_SELECTOR, '.dcpx-container')
return self.wait.wait_find_elements(locator)
@teststep
def vocab_select_game_operate(self,
stu_id,
book_id,
db_words,
do_right,
exam_type=2):
"""词汇选择游戏
:param book_id: 书籍id
:param db_words: 数据库查询单词数据
:param do_right: 是否做对
:param exam_type: 试卷类型, 新学， 已学
:param stu_id 学生id
"""
print('==== 词汇选择 ====\n')
word_info = {}
mine_answer_info = {}
start_time = round(time.time())
vocab_choice_containers = self.vocab_select_game_container()
for index in range(len(vocab_choice_containers)):
container = self.vocab_select_game_container()[index]
word_id = container.get_attribute('id')
if int(word_id) not in db_words:
self.base_assert.except_error('该单词不在查询单词列表中')
game_mode = container.get_attribute('mode')
answer_word = self.data.get_word_by_word_id(word_id)
explain_list = self.data.get_student_explain_list_by_word_id(
stu_id, book_id, word_id)
print('单词：', answer_word)
print('单词id', word_id)
print("解释列表：", explain_list)
options = self.vocab.options(container)
right_index = -1
if game_mode in ['1', '4']:
for i, x in enumerate(options):
if x.text.split('；') == explain_list:
print('正确答案：', x.text)
word_info[word_id] = (answer_word, x.text)
right_index = i
break
print('正确答案索引：', right_index)
if right_index == -1:
self.base_assert.except_error('选项列表中不存在该单词所有解释合并列表集')
right_index = 0
else:
if game_mode == '2':
question = self.vocab.ques_title(container)
if question.split('；') != explain_list:
self.base_assert.except_error('单词解释不为该单词所有解释合并列表集')
for i, y in enumerate(options):
opt_content = y.text.strip()
if opt_content == answer_word:
right_index = i
break
if do_right:
self.vocab.options(container)[right_index].click()
mine_answer_info[answer_word] = answer_word
else:
for i, x in enumerate(options):
if i != right_index:
mine_answer_info[answer_word] = x.text
x.click()
break
time.sleep(1)
print('-' * 30, '\n')
used_time = round(time.time()) - start_time
return mine_answer_info, used_time
@teststep
def spell_game_operate(self,
stu_id,
book_id,
db_words,
do_right,
exam_type=2):
"""测试类单词拼写类游戏过程"""
print('===== 单词拼写 =====\n')
start_time = round(time.time())
mine_answer_info = {}
for index in range(len(self.spell_word_game_container())):
container = self.spell_word_game_container()[index]
word_id = container.get_attribute('id')
answer_word = self.data.get_word_by_word_id(word_id)
print('单词id：', word_id)
print('正确单词：', answer_word)
if int(word_id) not in db_words:
self.base_assert.except_error('该单词不在查询单词列表中')
explain = self.spell.explain(container)
print('解释：', explain)
explain_list = self.data.get_student_explain_list_by_word_id(
stu_id, book_id, word_id)
if explain.split('；') != explain_list:
self.base_assert.except_error('该单词的解释不是该单词(已学单词)的所有解释的合并集')
self.spell.normal_spell_input_wrap(container).click()
if do_right:
self.spell.normal_spell_input_wrap(container).send_keys(
answer_word)
input_answer = answer_word
else:
random_str = ''.join(random.sample(string.ascii_lowercase, 3))
input_answer = random_str
self.spell.normal_spell_input_wrap(container).send_keys(
random_str)
mine_answer_info[answer_word] = input_answer
print('我输入的：', input_answer)
time.sleep(1)
print('-' * 30, '\n')
used_time = round(time.time()) - start_time
return mine_answer_info, used_time
@teststep
def listen_spell_game_operate(self, db_words, do_right, exam_type=2):
"""单词听写过程"""
print('===== 单词听写 =====\n')
start_time = round(time.time())
mine_answer = {}
for index in range(len(self.listen_spell_game_containers())):
container = self.listen_spell_game_containers()[index]
word_id = container.get_attribute('id')
answer_word = self.data.get_word_by_word_id(word_id)
print('单词id：', word_id)
print('正确单词：', answer_word)
if int(word_id) not in db_words:
self.base_assert.except_error('该单词不在查询单词列表中')
self.spell.normal_spell_input_wrap(container).click()
if do_right:
self.spell.normal_spell_input_wrap(container).send_keys(
answer_word)
input_answer = answer_word
else:
random_str = ''.join(random.sample(string.ascii_lowercase, 3))
input_answer = random_str
self.spell.normal_spell_input_wrap(container).send_keys(
random_str)
mine_answer[answer_word] = input_answer
print('我输入的：', input_answer)
time.sleep(1)
print('-' * 30, '\n')
used_time = round(time.time()) - start_time
return mine_answer, used_time
def spell_with_copy_operate(self,
word_info,
stu_id,
do_right,
bank_index,
skip_index_info,
wrong_index_info,
is_recite=False,
book_id=None):
"""带有闪卡抄写的单词拼写游戏
:param book_id: 书籍id
:param stu_id: 学生id
:param is_recite: 是否是复习
:param skip_index_info: 记录跳过单词的索引值
:param wrong_index_info: 错题索引收录信息
:param bank_index: 全部题的索引统计
:param do_right: 是否做全对
:param word_info: 闪卡记录的正确答案信息
"""
print('======= 默听游戏 ======= \n')
begin_time = round(time.time())
finish_word = []
index = 0
while self.wait_check_spell_page():
finish_count = len(finish_word)
_, _, word_explain_id = self.game_container()
print('题目索引：', bank_index[0])
print('默写解释(单词)id：', word_explain_id)
explain = self.word_explain()
print('默写解释：', explain)
answer_word = word_info[word_explain_id][0]
print('默写记录答案：', answer_word)
wrong_id = list(word_info.keys())[0]
skip_id = list(word_info.keys())[1] if len(word_info) > 1 else -1
if is_recite:
db_all_explain = WordBookSqlHandle(
).get_student_explain_list_by_word_id(stu_id, book_id,
word_explain_id)
print('查询到的单词解释：', db_all_explain)
print('解释分割：', explain.split('；'))
if db_all_explain != explain.split('；'):
self.base_assert.except_error('题目解释不是已学解释合并')
if word_explain_id in finish_word:
self.base_assert.except_error('单词已完成， 但是再次出现 ' +
word_explain_id)
if not do_right:
# if index == 0:
# time.sleep(30)
# wrong_index_info.append(bank_index[0])
# if self.game_container()[-1] == word_explain_id:
# self.base_assert.except_error('限制时间过后， 单词未发生变化')
# else:=
if word_explain_id == wrong_id:
wrong_index_info.append(bank_index[0])
self.spell_game_process(word_explain_id,
len(wrong_index_info),
right_answer=answer_word)
print('此单词错误次数：', len(wrong_index_info))
if len(wrong_index_info) == 4:
finish_word.append(word_explain_id)
else:
if word_explain_id == skip_id:
self.click_skip_btn()
print('点击跳过')
skip_index_info.append(bank_index[0])
self.skip_word_operate(word_explain_id,
len(skip_index_info))
print('此单词跳过次数：', len(skip_index_info))
if len(skip_index_info) == 4:
finish_word.append(word_explain_id)
else:
self.spell_game_process(word_explain_id,
do_right=True,
right_answer=answer_word)
finish_word.append(word_explain_id)
else:
self.spell_game_process(do_right=True,
right_answer=answer_word)
finish_word.append(word_explain_id)
if len(finish_word) == finish_count:
self.commit_btn().click()
time.sleep(1)
index += 1
bank_index[0] += 1
print('-' * 30, '\n')
spend_seconds = round(time.time()) - begin_time
return spend_seconds
def __init__(self):
self.data = WordBookSqlHandle()
self.home = WordHomePage()
self.slice = DictSlice()
class NewWordGameOperatePage(WordBookPublicElePage):
def __init__(self):
self.data = WordBookSqlHandle()
self.home = WordHomePage()
self.slice = DictSlice()
@teststeps
def new_word_study_process(self, stu_id, book_id, *, all_word_info, fl_change, do_right=False,
study_time_info=None, group_count=None, book_type="enhanced"):
"""单词学习过程"""
time_msg = study_time_info if study_time_info else {'结束时间': '', '大题用时': {}, '总用时': 0}
begin_time = round(time.time())
group_fluency, group_word_info = {}, {}
before_word_fluency, before_phrase_fluency = {}, {}
word_info, phrase_info = {}, {}
all_bank_index = [0]
wrong_word_index = {x: [] for x in ['还原单词', '听音选词', '汉译英', '单词拼写']}
wrong_phrase_index = {x: [] for x in ['英译汉', '强化炼句']}
bank_time = time_msg['大题用时'] = {x: 0 for x in ['闪卡练习', '还原单词', '词汇选择', '单词拼写', '强化炼句']}
spell_skip_word = []
while self.wait_check_container_page():
game_container, game_mode, explain_id = self.game_container()
# 每5个一组,可以同时存在单词和短语， 先做单词后短语，
# 单词在1-3之间的做题索引各不相同，具体规律如下
if not do_right:
if 0 < len(word_info) < 4:
if all_bank_index[0] == 19 + 4 * (len(word_info) - 1):
all_bank_index[0] = 0
if len(word_info) == 4:
if all_bank_index[0] == 33:
all_bank_index[0] = 0
if game_container == 'sk-container': # 闪卡类游戏
if book_type == 'enhanced':
spend_time = FlashWordPage().speak_flash_card_operate(group_word_info)
else:
spend_time = FlashWordPage().\
normal_flash_card_operate(stu_id, book_id, word_info=group_word_info, is_enhanced=False)
bank_time['闪卡练习'] += spend_time
if len(group_word_info) != group_count:
self.base_assert.except_error('当前组内单词数与应练单词数不一致， 组内单词数为%d, '
'应学单词数为%d' %(len(group_word_info), group_count))
# 通过闪卡游戏获取单词数和短语数，并同时获取对应的做题之前的F值
word_info = {x: group_word_info[x] for x in group_word_info if group_word_info[x][2] == '单词'}
phrase_info = {x: group_word_info[x] for x in group_word_info if group_word_info[x][2] == '短语'}
before_word_fluency = {x: self.data.get_explain_fluency_by_explain_id(stu_id, x)
for x in list(word_info.keys())}
before_phrase_fluency = {x: self.data.get_explain_fluency_by_explain_id(stu_id, x)
for x in list(phrase_info.keys())}
elif game_container == 'chxz-container': # 词汇选择游戏
index_info = []
study_words = {}
if game_mode == '2':
index_info = wrong_word_index['汉译英']
study_words = word_info
elif game_mode == '3':
index_info = wrong_word_index['听音选词']
study_words = word_info
elif game_mode == '1':
index_info = wrong_phrase_index['英译汉']
study_words = phrase_info
spend_time = VocabSelectPage().\
vocab_select_operate(study_words, do_right, game_mode, all_bank_index, wrong_index_info=index_info)
bank_time['词汇选择'] += spend_time
print('词汇选择-mode{}错题间隔：'.format(game_mode), index_info)
elif game_container == 'dcpx-container': # 单词拼写游戏
wrong_index_info = wrong_word_index['单词拼写']
if book_type == 'enhanced':
spend_time = SpellWordPage().\
spell_with_copy_operate(word_info, stu_id, do_right, all_bank_index, spell_skip_word,
wrong_index_info=wrong_index_info)
else:
spend_time = SpellWordPage().\
random_spell_game_operate(word_info, do_right, all_bank_index, wrong_index_info)
bank_time['单词拼写'] += spend_time
print('单词拼写错题间隔：', wrong_index_info)
elif game_container == 'qhlj-container': # 短语的强化炼句游戏
spend_time = SentenceStrengthenPage().\
sentence_strengthen_game_operate(phrase_info, do_right, all_bank_index,
wrong_index_info=wrong_phrase_index['强化炼句'])
bank_time['强化炼句'] += spend_time
print('强化炼句错题间隔：', wrong_phrase_index['强化炼句'])
elif game_container == 'hydc-container': # 还原单词游戏
spend_time = RestoreWordPage().restore_word_operate(word_info, do_right, all_bank_index,
wrong_index_info=wrong_word_index['还原单词'])
bank_time['还原单词'] += spend_time
print('还原单词错题间隔列表：', wrong_word_index['还原单词'])
used_time = round(time.time()) - begin_time
end_time = datetime.datetime.strftime(datetime.datetime.now(), "%Y-%m-%d %H:%M:%S")
time_msg['结束时间'] = end_time
time_msg['总用时'] += used_time
print(time_msg)
# 检验错题间隔是否正确
if not do_right:
if len(word_info):
self.check_new_word_wrong_interval(len(word_info), len(phrase_info), wrong_word_index, book_type)
if len(phrase_info):
self.check_new_word_wrong_interval(len(word_info), len(phrase_info), wrong_phrase_index,
is_phrase=True, book_type=book_type)
# 校验已完成单词的F值变化
self.check_new_word_fluency_operate(stu_id, book_id, before_word_fluency, before_phrase_fluency, fl_change)
# 再来一组的处理过程
all_word_info.update(group_word_info)
if self.wait_check_finish_page():
finish_content = self.finish_content()
print(finish_content)
if self.finish_first_btn().text == "再来一组":
content_num = re.findall(r'\d+', self.content_desc())
rest_word_count = int(content_num[0]) - int(content_num[-1])
next_group_count = 5 if rest_word_count >= 5 else rest_word_count
self.finish_first_btn().click()
time.sleep(1)
self.new_word_study_process(stu_id, book_id, all_word_info=all_word_info, fl_change=fl_change,
do_right=do_right, study_time_info=time_msg,
group_count=next_group_count, book_type=book_type)
else:
self.exit_icon().click()
@teststep
def check_new_word_fluency_operate(self, stu_id, book_id, before_word_fluency, before_phrase_fluency, fl_change):
"""
新词F值查看主要步骤
:param stu_id: 学生id
:param book_id: 图书id
:param before_word_fluency: 学前单词熟练度
:param before_phrase_fluency: 学前短语熟练度
:param fl_change: 是否发生F值变化
:return:
"""
wrong_word_fluency = {}
right_word_fluency = {}
if before_word_fluency:
end_index = 1 if len(before_word_fluency) == 1 else 2
wrong_word_fluency.update(self.slice.dict_slice(before_word_fluency, end=end_index))
right_word_fluency.update(self.slice.dict_slice(before_word_fluency, start=end_index))
if len(before_phrase_fluency):
wrong_word_fluency.update(self.slice.dict_slice(before_phrase_fluency, end=1))
right_word_fluency.update(self.slice.dict_slice(before_phrase_fluency, start=1))
self.check_words_fluency_value(stu_id, wrong_word_fluency, f_is_change=fl_change)
self.check_words_fluency_value(stu_id, right_word_fluency, f_is_change=fl_change, is_right=True)
# 将错题写入错题记录文件
if wrong_word_fluency:
pro_path = os.path.abspath('.')
with open(pro_path + '\\app\\wordbook\\test_data\\wrong.json', 'r') as f:
note_dict = json.load(f)
explain_id_list = list(wrong_word_fluency.keys())
word_id_list = [WordBookSqlHandle().get_word_id_by_explain_id(stu_id, x) for x in explain_id_list]
already_study_word_info = {x: WordBookSqlHandle().get_student_explain_list_by_word_id(stu_id, book_id, x)
for x in word_id_list}
note_dict.update(already_study_word_info)
with open(pro_path + '\\app\\wordbook\\test_data\\wrong.json', 'w') as f:
f.write(json.dumps(note_dict, ensure_ascii=False))
f.close()
@teststep
def check_new_word_wrong_interval(self, word_count, phrase_count, wrong_index_info, book_type, is_phrase=False):
"""查看新词错题间隔操作"""
if not is_phrase:
listen_wrong_index = wrong_index_info['汉译英']
if len(listen_wrong_index) != 5:
self.base_assert.except_error('单词听音选词错题次数不为5！')
else:
if listen_wrong_index != [listen_wrong_index[0] + 2 * x for x in range(5)]:
self.base_assert.except_error('单词听音选词错误间隔不正确， 请核查')
spell_index = wrong_index_info['单词拼写']
if book_type == "enhanced":
restore_wrong_index = wrong_index_info['听音选词']
if len(restore_wrong_index) != 5:
self.base_assert.except_error('还原单词错题次数不为5！')
if restore_wrong_index != [0, 2, 4, 6, 8]:
self.base_assert.except_error('还原单词错题间隔不正确，请查实')
choice_wrong_index = wrong_index_info['还原单词']
if len(choice_wrong_index) != 5:
self.base_assert.except_error('单词汉译英错题次数不为5！')
if choice_wrong_index != [choice_wrong_index + 2 * x for x in range(5)]:
self.base_assert.except_error('单词汉译英错题间隔不正确， 请核查')
if len(spell_index) != 4:
self.base_assert.except_error('单词拼写错题次数不为4！')
if spell_index != [spell_index[0] + 2 * x for x in range(4)]:
self.base_assert.except_error('单词拼写错误间隔不正确， 请核查')
else:
if len(spell_index) != 5:
self.base_assert.except_error('单词拼写错题次数不为5！')
if spell_index != [spell_index[0] + 2 * x for x in range(5)]:
self.base_assert.except_error('单词拼写错误间隔不正确， 请核查')
else:
choice_index = wrong_index_info['英译汉']
if choice_index != [0, 2, 4, 6, 8]:
self.base_assert.except_error('短语英译汉错题间隔不正确，请核查')
if word_count:
if phrase_count == 1:
check_index_list = [7, 9, 10, 11, 12]
else:
start_index = 7 + phrase_count
check_index_list = [start_index + 2*x for x in range(phrase_count)]
check_index_list.extend([check_index_list[-1] + (x+1) for x in range(5-len(check_index_list))])
else:
check_index_list = [2 * phrase_count - 1 + 2 * x for x in range(5)]
sentence_enhance_index = wrong_index_info['强化炼句']
print('计算强化炼句错题间隔:', check_index_list)
if sentence_enhance_index != check_index_list:
self.base_assert.except_error('短语强化炼句错误间隔不正确， 请核查')