DeepSeek API 配置

// ==UserScript== // @name 【免费】学习通助手视频-章节测试-自动挂机-防清进度 // @namespace unrival // @version 1.0.0 // @description 【🤖️AI答题】题库没有的会自动AI答题【🔊功能齐全】支持视频、音频倍速秒过；文档、图书自动完成；字体解密；章节测验、课后作业、考试自动答题、自动提交、自动收录答案；支持自动切换任务点等 // @author unrival // @run-at document-idle // @storageName unrivalxxt // @match *://*.chaoxing.com/* // @match *://*.edu.cn/* // @match *://*.nbdlib.cn/* // @match *://*.hnsyu.net/* // @match *://*.ac.cn/* // @icon http://pan-yz.chaoxing.com/favicon.ico // @grant unsafeWindow // @grant GM_xmlhttpRequest // @grant GM_setValue // @grant GM_getValue // @grant GM_deleteValue // @grant GM_addValueChangeListener // @grant GM_info // @connect mooc1-1.neauce.com // @connect mooc1-1.chaoxing.com // @connect mooc1.chaoxing.com // @connect mooc1-2.chaoxing.com // @connect mooc1-2.neauce.com // @connect mooc1-api.chaoxing.com // @connect mooc2-ans.chaoxing.com // @connect passport2-api.chaoxing.com // @connect 14.29.190.187 // @connect cx.icodef.com // @connect api.deepseek.com // @license GPL-3.0-or-later // @original-script https://greasyfork.org/zh-CN/scripts/453287 // @original-script https://scriptcat.org/zh-CN/script-show-page/379 // @original-author unrival // @original-license GPL-3.0-or-later //@ 如果脚本提示添加安全网址，请将脚本提示内容填写到下方区域，一行一个，如果不会，请加群询问 //@ 安全网址请填写在上方空白区域 // ==/UserScript== (() => { $(function() { setTimeout(()=>{ $("body").removeAttr("onselectstart"); $("html").css("user-select", "unset"); Object.entries(UE.instants).forEach(item=>{ item[1].options.disablePasteImage = false; item[1].removeListener('beforepaste',editorPaste) }) }, 1000); }) var jumpType = 1, // 0:智能模式，1:遍历模式，2:不跳转，如果智能模式出现无限跳转/不跳转情况，请切换为遍历模式 disableMonitor = 0, // 0:无操作，1:解除多端学习监控，开启此功能后可以多端学习，不会被强制下线。 randomDo = 1, //将0改为1，找不到答案的单选、多选、判断就会自动选【B、ABCD、错】，只在规定正确率不为100%时才生效 enableBackground = 0, //是否对接超星挂机小助手，需要先安装对应脚本 //----------------------------------------------------------------------------------------------------- autoLogin = 0, phoneNumber = '', password = ''; //----------------------------------------------------------------------------------------------------- var host = 'http://14.29.190.187:54223/', rate = GM_getValue('unrivalrate', '1'),//倍速 token = GM_getValue('tikutoken',"111"),//题库token accuracy = GM_getValue('accuracy',60), //章节测试正确率百分比，在答题正确率在规定之上并且允许自动提交时才会提交答案 ctUrl = 'https://cx.icodef.com/wyn-nb?v=4', getQueryVariable = (variable) => { let q = _l.search.substring(1), v = q.split("&"), r = false; for (let i = 0, l = v.length; i < l; i++) { let p = v[i].split("="); p[0] == variable && (r = p[1]); } return r; }, getCookie = name => `; ${document.cookie}`.split(`; ${name}=`).pop().split(';').shift(), isCat = GM_info.scriptHandler == 'ScriptCat', _w = unsafeWindow, _d = _w.document, _l = _w.location, _p = _l.protocol, _h = _l.host, //isEdge = _w.navigator.userAgent.includes("Edg/"), isFf = _w.navigator.userAgent.includes("Firefox"), isMobile = _w.navigator.userAgent.includes("Android"), stop = false, handleImgs = (s) => { imgEs = s.match(/(]*)>)/); if (imgEs) { for (let j = 0, k = imgEs.length; j < k; j++) { let urls = imgEs[j].match( /http[s]?:\/\/(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*,]|(?:%[0-9a-fA-F][0-9a-fA-F]))+/), url; if (urls) { url = urls[0].replace(/http[s]?:\/\//, ''); s = s.replaceAll(imgEs[j], url); } } } return s; }, trim = (s) => { return handleImgs(s).replaceAll('javascript:void(0);', '').replaceAll(" ", '').replaceAll("，", ',').replaceAll( "。", '.').replaceAll("：", ':').replaceAll("；", ';').replaceAll("？", '?').replaceAll("（", '(').replaceAll("）", ')').replaceAll("“", '"') .replaceAll("”", '"').replaceAll("！", '!').replaceAll("-", ' ').replace(/(<([^>]+)>)/ig, '') .replace(/^\s+/ig, '').replace(/\s+$/ig, ''); }, cVersion = 999, classId = getQueryVariable('clazzid') || getQueryVariable('clazzId') || getQueryVariable('classid') || getQueryVariable('classId'), courseId = getQueryVariable('courseid') || getQueryVariable('courseId'), UID = getCookie('_uid') || getCookie('UID'), FID = getCookie('fid'), jq = _w.top.$ || _w.top.jQuery; const aiTikuModule = { config: { deepseekApiUrl: 'https://api.deepseek.com/chat/completions', apiKey: GM_getValue('deepseekApiKey', ''), model: 'deepseek-chat', timeout: 60000, maxRetries: 3, retryDelay: 2000 }, // 初始化配置 init: function(config = {}) { this.config = { ...this.config, ...config }; this.config.apiKey = GM_getValue('deepseekApiKey', ''); // 调试输出 console.log('AI模块初始化 - API密钥状态:'); console.log('是否有密钥:', this.config.apiKey ? '是' : '否'); if (this.config.apiKey) { console.log('密钥长度:', this.config.apiKey.length); console.log('密钥前10位:', this.config.apiKey.substring(0, 10)); console.log('密钥后8位:', this.config.apiKey.substring(this.config.apiKey.length - 8)); console.log('完整密钥:', this.config.apiKey); } // 如果有保存的API密钥，检查格式 if (this.config.apiKey) { const apiKey = this.config.apiKey.trim(); // 基本格式检查 let isValidFormat = true; let errorMsg = ''; if (!apiKey) { isValidFormat = false; errorMsg = 'API密钥为空'; } else if (!apiKey.startsWith('sk-')) { isValidFormat = false; errorMsg = 'API密钥应以"sk-"开头'; } else if (apiKey.length < 30 || apiKey.length > 200) { // 放宽长度检查 isValidFormat = false; errorMsg = `API密钥长度异常 (${apiKey.length} 字符)`; } if (!isValidFormat) { this.log(`保存的API密钥格式可能有问题: ${errorMsg}`, 'warn'); } else { this.log('已加载保存的API密钥', 'info'); } } else { this.log('未检测到API密钥，请配置后使用AI功能', 'info'); } this.log('AI题库模块初始化完成'); }, // 日志记录功能 log(message, type = 'info') { const timestamp = new Date().toLocaleString('zh-CN'); const logMessage = `[${timestamp}] [AI题库-${type}] ${message}`; console.log(logMessage); }, // 生成缓存键 generateCacheKey(question, type) { return `ai_tiku_${type}_${question.trim().substring(0, 100)}`; }, // 获取缓存 getCache(key) { try { const cached = GM_getValue(key, null); if (cached) { const cacheItem = JSON.parse(cached); // 检查是否过期（默认缓存24小时） if (cacheItem.expireAt > Date.now()) { return cacheItem.data; } else { // 清除过期缓存 GM_deleteValue(key); } } } catch (e) { this.log(`获取缓存失败: ${e.message}`, 'error'); } return null; }, // 设置缓存 setCache(key, data, expireHours = 1) { try { const cacheItem = { key, data, timestamp: Date.now(), expireAt: Date.now() + (expireHours * 60 * 60 * 1000) }; GM_setValue(key, JSON.stringify(cacheItem)); } catch (e) { this.log(`设置缓存失败: ${e.message}`, 'error'); } }, // 构建DeepSeek API请求消息 buildRequestMessages(question, type, options = {}) { let systemPrompt = '你是一个专业的答题助手，请根据题目内容和选项，提供正确的答案和详细的解析。'; let optionsStr = ''; if (Object.keys(options).length > 0) { optionsStr = '选项：\n'; for (let key in options) { optionsStr += `${key}: ${options[key]}\n`; } } let questionPrompt = ''; if (type === '填空题') { // 填空题特殊提示 questionPrompt = `题目类型：填空题\n题目内容：${question}\n${optionsStr}\n请提供以下格式的回答：\n答案：[答案，多个空用|分隔]\n解析：[详细解释每个空的答案]`; } else if (type === '简答题') { // 简答题特殊提示 questionPrompt = `题目类型：简答题\n题目内容：${question}\n${optionsStr}\n请提供详细、准确的回答，字数不少于50字。`; } else { questionPrompt = `题目类型：${type}\n题目内容：${question}\n${optionsStr}\n请提供以下格式的回答：\n答案：[选项]\n解析：[详细解释为什么选择这个答案]`; } return [ { role: 'system', content: systemPrompt }, { role: 'user', content: questionPrompt } ]; }, debugApiKey: function() { const savedKey = GM_getValue('deepseekApiKey', ''); console.log('===== API密钥调试信息 ====='); console.log('保存的密钥长度:', savedKey.length); console.log('保存的密钥前10位:', savedKey.substring(0, 10)); console.log('保存的密钥后8位:', savedKey.substring(savedKey.length - 8)); console.log('当前配置的密钥长度:', this.config.apiKey ? this.config.apiKey.length : 0); console.log('当前配置的密钥前10位:', this.config.apiKey ? this.config.apiKey.substring(0, 10) : '无'); console.log('=========================='); return savedKey; }, // 调用DeepSeek API async callDeepSeekApi(question, type, options = {}) { // 检查API密钥 if (!this.config.apiKey) { this.log('DeepSeek API密钥未配置', 'error'); return { success: false, error: 'API密钥未配置' }; } // 尝试从缓存获取 const cacheKey = this.generateCacheKey(question, type); const cachedResult = this.getCache(cacheKey); if (cachedResult && cachedResult.answer && cachedResult.analysis) { this.log(`从缓存获取答案: ${question.substring(0, 20)}...`); return { success: true, data: cachedResult }; } // 构建请求参数 const requestParams = { model: this.config.model, messages: this.buildRequestMessages(question, type, options), temperature: 0.3, max_tokens: 1000 }; // 带重试机制的请求函数 const makeRequest = (retryCount = 0) => { return new Promise((resolve) => { GM_xmlhttpRequest({ method: 'POST', url: this.config.deepseekApiUrl, headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.config.apiKey}` }, data: JSON.stringify(requestParams), timeout: this.config.timeout, onload: (response) => { try { const result = JSON.parse(response.responseText); if (result.choices && result.choices.length > 0) { const content = result.choices[0].message.content; // 改进后的答案和解析提取逻辑 let answer = '未找到答案'; let analysis = '未找到解析'; console.log('=== AI答案提取调试 ==='); console.log('AI返回的原始内容:', content); console.log('题目类型:', type); console.log('原始内容长度:', content.length); console.log('原始内容前200字符:', content.substring(0, 200)); // 简答题特殊处理：只提取答案，不提取解析 if (type === '简答题') { // 尝试提取代码块（```java 或 ```） // 使用 [\s\S] 匹配所有字符包括换行符 const codeBlockPattern = /```(?:java)?\s*([\s\S]*?)```/i; const codeMatch = content.match(codeBlockPattern); console.log('简答题代码块匹配尝试:', { hasMatch: !!codeMatch, matchResult: codeMatch ? codeMatch[1] : null, contentLength: content.length, contentPreview: content.substring(0, 200) }); if (codeMatch && codeMatch[1] && codeMatch[1].trim()) { answer = codeMatch[1].trim(); analysis = ''; console.log('简答题：提取到代码块作为答案'); console.log('提取的代码块长度:', answer.length); console.log('提取的代码块预览:', answer.substring(0, 100)); } else { // 如果没有代码块，尝试提取"答案："之后的内容 const answerPattern = /答案[：:]\s*([\s\S]*?)(?=\s*解析|$)/i; const answerMatch = content.match(answerPattern); console.log('简答题"答案："匹配尝试:', { hasMatch: !!answerMatch, matchResult: answerMatch ? answerMatch[1] : null }); if (answerMatch && answerMatch[1] && answerMatch[1].trim()) { answer = answerMatch[1].trim(); analysis = ''; console.log('简答题：提取"答案："后的内容'); } else { // 都没有，使用整个内容 answer = content.trim(); analysis = ''; console.log('简答题：使用整个AI返回内容作为答案'); } } } else { // 其他题型使用"答案："格式提取 const answerPatterns = [ /答案[：:]\s*\[([^\]]+)\]/, // 答案：[内容] /答案[：:]\s*([^\r\n]+)/, // 答案：内容（单行） /答案[：:]\s*([\s\S]*?)(?=\s*解析|$)/i // 答案：内容（多行） ]; const analysisPatterns = [ /解析[：:]\s*\[([^\]]+)\]/, // 解析：[内容] /解析[：:]\s*([^\r\n]+)/, // 解析：内容（单行） /解析[：:]\s*([\s\S]*)/ // 解析：内容（多行） ]; // 应用答案匹配模式 for (let i = 0; i < answerPatterns.length; i++) { const pattern = answerPatterns[i]; const match = content.match(pattern); console.log(`尝试答案匹配模式${i+1}:`, pattern); if (match && match[1].trim()) { answer = match[1].trim(); console.log(`模式${i+1}匹配成功，答案:`, answer); break; } else { console.log(`模式${i+1}匹配失败`); } } // 应用解析匹配模式 for (let i = 0; i < analysisPatterns.length; i++) { const pattern = analysisPatterns[i]; const match = content.match(pattern); console.log(`尝试解析匹配模式${i+1}:`, pattern); if (match && match[1].trim()) { analysis = match[1].trim(); console.log(`模式${i+1}匹配成功，解析:`, analysis); break; } else { console.log(`模式${i+1}匹配失败`); } } } console.log('最终提取的答案:', answer); console.log('最终提取的解析:', analysis); console.log('======================'); const processedResult = { answer: answer, analysis: analysis, rawContent: content, timestamp: Date.now() }; // 缓存结果 this.setCache(cacheKey, processedResult); resolve({success: true, data: processedResult}); } else { this.log(`API返回无效结果: ${response.responseText}`, 'error'); resolve({success: false, error: 'API返回无效结果'}); } } catch (e) { this.log(`解析API响应失败: ${e.message}`, 'error'); resolve({success: false, error: '解析响应失败'}); } }, onerror: (error) => { this.log(`API调用失败: ${error.message}`, 'error'); if (retryCount < this.config.maxRetries) { this.log(`将在 ${this.config.retryDelay}ms 后进行第 ${retryCount + 1} 次重试...`, 'info'); setTimeout(() => { makeRequest(retryCount + 1).then(resolve); }, this.config.retryDelay); } else { this.log(`已达到最大重试次数 (${this.config.maxRetries})，放弃重试`, 'error'); resolve({ success: false, error: `网络错误: ${error.message} (已重试${retryCount}次)` }); } }, ontimeout: () => { this.log('API调用超时', 'error'); console.log('超时详情:', { timeout: this.config.timeout, question: question.substring(0, 50), type: type, retryCount: retryCount }); if (retryCount < this.config.maxRetries) { this.log(`将在 ${this.config.retryDelay}ms 后进行第 ${retryCount + 1} 次重试...`, 'info'); setTimeout(() => { makeRequest(retryCount + 1).then(resolve); }, this.config.retryDelay); } else { this.log(`已达到最大重试次数 (${this.config.maxRetries})，放弃重试`, 'error'); resolve({ success: false, error: `请求超时 (已重试${retryCount}次)` }); } } }); }); }; // 开始第一次请求 return makeRequest(); }, // 处理题目 async processQuestion(questionObj) { this.log(`开始处理题目: ${questionObj.question.substring(0, 30)}...`); try { const result = await this.callDeepSeekApi( questionObj.question, questionObj.type, questionObj.options ); if (result.success) { // 更新题目对象 questionObj.aiAnswer = result.data.answer; questionObj.aiAnalysis = result.data.analysis; questionObj.timestamp = result.data.timestamp; this.log(`题目处理完成: ${questionObj.question.substring(0, 20)}...`, 'info'); return questionObj; } else { this.log(`题目处理失败: ${result.error}`, 'error'); questionObj.aiAnalysis = `AI解析失败: ${result.error}`; return questionObj; } } catch (e) { this.log(`处理题目时发生异常: ${e.message}`, 'error'); questionObj.aiAnalysis = `处理异常: ${e.message}`; return questionObj; } }, // 显示AI解析 showAiAnalysis(questionId, analysis, answer) { // 查找对应的题目元素 const questionElement = document.querySelector(`[id-param="${questionId.replace('answer', '')}"]`); if (!questionElement) { this.log(`未找到题目元素: ${questionId}`, 'error'); return; } // 创建解析显示区域 let analysisDiv = document.getElementById(`ai-analysis-${questionId}`); if (!analysisDiv) { analysisDiv = document.createElement('div'); analysisDiv.id = `ai-analysis-${questionId}`; analysisDiv.className = 'ai-analysis'; analysisDiv.style.cssText = ` background: #f8f9fa; border: 2px solid #4a9eff; border-radius: 8px; padding: 15px; margin-top: 15px; font-size: 14px; box-shadow: 0 2px 8px rgba(0,0,0,0.1); transition: all 0.3s ease; `; // 插入到题目后面 questionElement.parentNode.appendChild(analysisDiv); } // 设置内容，添加可折叠功能 analysisDiv.innerHTML = `

✨ DeepSeek AI 解析

✅ AI答案: ${answer || '未生成答案'}

📝 解析思路:

${analysis || '暂无解析'}

由 DeepSeek AI 提供 | 解析时间: ${new Date().toLocaleTimeString()}

`; // 添加折叠功能 const toggleBtn = analysisDiv.querySelector('.ai-analysis-toggle'); const contentDiv = analysisDiv.querySelector('.ai-analysis-content'); toggleBtn.addEventListener('click', () => { if (contentDiv.style.display === 'none') { contentDiv.style.display = 'block'; toggleBtn.textContent = '收起'; } else { contentDiv.style.display = 'none'; toggleBtn.textContent = '展开'; } }); // 如果API密钥未设置，添加提示 if (!this.config.apiKey) { const apiWarning = document.createElement('div'); apiWarning.style.cssText = ` background: #fff3cd; border: 1px solid #ffeaa7; border-radius: 4px; padding: 10px; margin-top: 10px; color: #856404; `; apiWarning.innerHTML = ` ⚠️ 未设置DeepSeek API密钥，AI功能受限。
`; apiWarning.querySelector('.set-api-key-btn').addEventListener('click', () => { this.showApiKeyConfig(); }); analysisDiv.appendChild(apiWarning); } }, // 显示API密钥配置界面 showApiKeyConfig() { // 创建配置界面 const configDiv = document.createElement('div'); configDiv.style.cssText = ` position: fixed; top: 50%; left: 50%; transform: translate(-50%, -50%); background: white; padding: 30px; border-radius: 10px; box-shadow: 0 5px 20px rgba(0,0,0,0.2); z-index: 10000; min-width: 400px; max-width: 80%; max-height: 80vh; overflow-y: auto; `; configDiv.innerHTML = ` DeepSeek API 配置

DeepSeek API 配置

配置步骤

1

访问 DeepSeek平台获取API密钥
2

复制您的API密钥并粘贴到下方输入框
3

点击保存即可启用AI答题功能

API密钥

密钥仅保存在本地浏览器中，不会上传到任何服务器

`; // 添加到页面 document.body.appendChild(configDiv); // 添加事件监听 document.getElementById('saveApiKeyBtn').addEventListener('click', () => { const apiKey = document.getElementById('deepseekApiKeyInput').value.trim(); if (apiKey) { this.saveApiKey(apiKey); configDiv.remove(); // 显示成功提示 const successMsg = document.createElement('div'); successMsg.style.cssText = ` position: fixed; top: 20px; right: 20px; background: #d4edda; color: #155724; padding: 15px 20px; border-radius: 4px; border: 1px solid #c3e6cb; z-index: 10001; box-shadow: 0 2px 10px rgba(0,0,0,0.1); `; successMsg.textContent = 'DeepSeek API密钥已保存，AI功能已启用！'; document.body.appendChild(successMsg); setTimeout(() => successMsg.remove(), 3000); } else { alert('请输入有效的API密钥'); } }); document.getElementById('cancelConfigBtn').addEventListener('click', () => { configDiv.remove(); }); // 点击背景关闭 configDiv.addEventListener('click', (e) => { if (e.target === configDiv) { configDiv.remove(); } }); }, // 保存API密钥 saveApiKey(apiKey) { GM_setValue('deepseekApiKey', apiKey); this.config.apiKey = apiKey; this.log('DeepSeek API密钥已保存'); }, initAIInterface: function() { // 等待题库配置面板加载 const checkInterval = setInterval(() => { const tikuPanel = document.getElementById('tikupeizhi'); if (tikuPanel) { clearInterval(checkInterval); this.addAIConfigToPanel(tikuPanel); } }, 500); }, addAIConfigToPanel: function(tikuPanel) { // 检查是否已经添加了AI配置 if (document.getElementById('aiConfigSection')) { return; // 已经添加过了 } // 创建AI配置部分 const aiConfigHTML = ` AI题库配置

AI题库配置中心

AI功能状态

当题库找不到答案时自动调用AI

支持智能推理和答案生成

自动缓存AI回答结果

DeepSeek API密钥

密钥仅保存在本地，不会上传到任何服务器

启用AI题库（当题库找不到答案时使用）

`; // 找到panel-body并添加AI配置 const panelBody = tikuPanel.querySelector('.panel-body'); if (panelBody) { // 如果有多个panel-body，选择最后一个（通常是第二个） const panels = tikuPanel.querySelectorAll('.panel-body'); const targetPanel = panels.length > 1 ? panels[1] : panelBody; targetPanel.innerHTML += aiConfigHTML; // 绑定事件 this.bindAIConfigEvents(); } }, bindAIConfigEvents: function() { // 加载保存的API密钥 const savedApiKey = GM_getValue('deepseekApiKey', ''); if (savedApiKey) { const keyInput = document.getElementById('deepseekKey'); if (keyInput) keyInput.value = savedApiKey; } // 展开/收起AI配置 const toggleBtn = document.getElementById('toggleAI'); if (toggleBtn) { toggleBtn.onclick = () => { const aiSection = document.getElementById('aiConfigSection'); const aiStatus = document.getElementById('aiStatus'); if (aiSection.style.display === 'none') { aiSection.style.display = 'block'; aiStatus.textContent = '✅ AI已启用'; aiStatus.style.color = 'green'; } else { aiSection.style.display = 'none'; aiStatus.textContent = '❌ AI已禁用'; aiStatus.style.color = 'red'; } }; } const saveKeyBtn = document.getElementById('saveDeepseekKey'); if (saveKeyBtn) { saveKeyBtn.onclick = () => { const apiKey = document.getElementById('deepseekKey').value.trim(); if (apiKey) { this.saveApiKey(apiKey); this.showMessage('DeepSeek API密钥已保存', 'success'); } else { this.showMessage('请输入有效的API密钥', 'error'); } } } const enableAICheckbox = document.getElementById('enableAI'); if (enableAICheckbox) { enableAICheckbox.onchange = function() { GM_setValue('enableAI', this.checked); const aiStatus = document.getElementById('aiStatus'); if (aiStatus) { aiStatus.textContent = this.checked ? '✅ AI已启用' : '❌ AI已禁用'; aiStatus.style.color = this.checked ? 'green' : 'red'; } this.showMessage(`AI题库功能已${this.checked ? '启用' : '禁用'}`, 'info'); }.bind(this); } // 测试AI连接 const testAIBtn = document.getElementById('testAI'); if (testAIBtn) { testAIBtn.onclick = async () => { // 禁用按钮防止重复点击 testAIBtn.disabled = true; const originalText = testAIBtn.innerHTML; testAIBtn.innerHTML = ' 测试中...'; try { const result = await this.testConnection(); if (resultDiv) { if (result.success) { resultDiv.innerHTML = `

${result.message || '测试成功'}

答案：${result.answer || '未获取'}
解析：${result.analysis || '未获取'}

${new Date().toLocaleString()}

`; } else { resultDiv.innerHTML = `

测试失败

错误：${result.error || '未知错误'}
请检查API密钥是否正确，网络是否正常

`; } resultDiv.style.display = 'block'; } } catch (error) { if (resultDiv) { resultDiv.innerHTML = `

测试异常

${error.message || '未知错误'}

`; resultDiv.style.display = 'block'; } } finally { // 恢复按钮状态 testAIBtn.disabled = false; testAIBtn.innerHTML = originalText; } }; } // 清除AI缓存 const clearCacheBtn = document.getElementById('clearAICache'); if (clearCacheBtn) { clearCacheBtn.onclick = () => { const keys = GM_listValues(); let clearedCount = 0; keys.forEach(key => { if (key.startsWith('ai_tiku_')) { GM_deleteValue(key); clearedCount++; } }); this.showMessage(`已清除 ${clearedCount} 个AI缓存`, 'success'); }; } }, showMessage: function(message, type = 'info') { const logDiv = document.getElementById('log'); if (logDiv) { const now = new Date(); const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`; const color = type === 'success' ? 'green' : type === 'error' ? 'red' : 'blue'; logDiv.innerHTML += `[${timeStr}] ${message}
`; logDiv.scrollTop = logDiv.scrollHeight; } }, // 测试AI连接（注意：这里需要添加逗号） testConnection: async function() { this.log('开始测试AI连接...', 'info'); // 检查API密钥 if (!this.config.apiKey) { this.showApiKeyConfig(); return { success: false, error: '未设置API密钥', message: '请先配置DeepSeek API密钥' }; } // 显示测试中状态 this.showTestStatus('正在测试AI连接...', 'info'); // 创建一个包含时间戳的测试问题，确保每次都是新的 const timestamp = Date.now(); const testQuestion = { question: `测试AI连接 - ${timestamp}：中国的首都是哪里？`, type: "单选题"&&"填空题", options: { "A": "北京", "B": "上海", "C": "广州", "D": "深圳" }, questionId: `test_${timestamp}` }; try { // 生成唯一的缓存键，确保不使用缓存 const cacheKey = `ai_test_${timestamp}`; // 删除可能存在的旧测试缓存 GM_deleteValue(cacheKey); // 使用testQuestion变量构建请求消息 const requestParams = { model: this.config.model, messages: [ { role: 'system', content: '你是一个AI助手，请回答一个简单的测试问题。回答格式：答案：[选项]\n解析：[这是一个测试连接]' }, { role: 'user', content: `问题：${testQuestion.question}\n类型：${testQuestion.type}\n选项：${JSON.stringify(testQuestion.options)}\n请用指定格式回答。` } ], temperature: 0.3, max_tokens: 1000 }; // 发送实时API请求 return new Promise((resolve) => { GM_xmlhttpRequest({ method: 'POST', url: this.config.deepseekApiUrl, headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${this.config.apiKey.trim()}`, // 确保trim 'Accept': 'application/json' }, data: JSON.stringify(requestParams), timeout: this.config.timeout, onload: (response) => { try { // 首先检查响应状态 if (response.status !== 200) { this.log(`API返回状态码: ${response.status}`, 'error'); let errorMsg = `HTTP错误 ${response.status}`; try { const errorData = JSON.parse(response.responseText); if (errorData.error && errorData.error.message) { errorMsg = errorData.error.message; } } catch (e) {} this.showTestResult({ success: false, error: errorMsg, message: 'AI连接测试失败' }); resolve({success: false, error: errorMsg}); return; } const result = JSON.parse(response.responseText); if (result.choices && result.choices.length > 0) { const content = result.choices[0].message.content; // 提取答案和解析 let answer = '未获取到答案'; let analysis = '未获取到解析'; // 提取答案 const answerMatch = content.match(/答案[：:]\s*\[([^\]]+)\]/); if (answerMatch && answerMatch[1]) { answer = answerMatch[1].trim(); } // 提取解析 const analysisMatch = content.match(/解析[：:]\s*\[([^\]]+)\]/); if (analysisMatch && analysisMatch[1]) { analysis = analysisMatch[1].trim(); } else { analysis = 'AI连接测试成功，返回内容：' + content.substring(0, 100) + '...'; } const processedResult = { answer: answer, analysis: analysis, rawContent: content, timestamp: Date.now(), isRealTime: true }; this.log('AI连接测试成功！', 'success'); // 显示实时结果 this.showTestResult({ success: true, message: '🎉 AI连接测试成功！', answer: processedResult.answer, analysis: processedResult.analysis, rawContent: processedResult.rawContent, timestamp: processedResult.timestamp }); resolve({ success: true, message: 'AI连接测试成功！', answer: processedResult.answer, analysis: processedResult.analysis, isRealTime: true }); } else { // 检查是否有错误信息 if (result.error) { this.log(`API返回错误: ${JSON.stringify(result.error)}`, 'error'); this.showTestResult({ success: false, error: result.error.message || 'API错误', message: 'AI连接测试失败' }); resolve({success: false, error: result.error.message || 'API错误'}); } else { this.log(`API返回无效结果: ${response.responseText}`, 'error'); this.showTestResult({ success: false, error: 'API返回无效结果', message: 'AI连接测试失败' }); resolve({success: false, error: 'API返回无效结果'}); } } } catch (e) { this.log(`解析API响应失败: ${e.message}`, 'error'); this.showTestResult({ success: false, error: '解析响应失败: ' + e.message, message: 'AI连接测试失败' }); resolve({ success: false, error: '解析响应失败: ' + e.message }); } }, onerror: (error) => { this.log(`API调用失败: ${error.message}`, 'error'); this.showTestResult({ success: false, error: `网络错误: ${error.message}`, message: 'AI连接测试失败' }); resolve({ success: false, error: `网络错误: ${error.message}` }); }, ontimeout: () => { this.log('API调用超时', 'error'); this.showTestResult({ success: false, error: '请求超时', message: 'AI连接测试失败' }); resolve({ success: false, error: '请求超时' }); } }); }); } catch (e) { this.log(`AI连接测试异常: ${e.message}`, 'error'); this.showTestResult({ success: false, error: e.message, message: 'AI连接测试异常' }); return { success: false, error: `测试异常: ${e.message}` }; } }, // 显示测试状态 showTestStatus: function(message, type = 'info') { const resultDiv = document.getElementById('aiTestResult'); if (!resultDiv) return; resultDiv.style.display = 'block'; const colors = { info: '#3498db', success: '#2ecc71', error: '#e74c3c', warning: '#f39c12' }; resultDiv.innerHTML = `

${message}

`; }, // 显示测试结果 showTestResult: function(result) { const resultDiv = document.getElementById('aiTestResult'); if (!resultDiv) return; resultDiv.style.display = 'block'; if (result.success) { resultDiv.className = 'test-result success'; resultDiv.innerHTML = `

${result.message}

📝 测试题目：中国的首都是哪里？

✅ AI答案：${result.answer || '未获取到答案'}

💡 AI解析：${result.analysis || '未获取到解析'}

实时测试时间: ${new Date().toLocaleString('zh-CN', { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' })}

`; } else { resultDiv.className = 'test-result error'; resultDiv.innerHTML = `

${result.message || 'AI连接测试失败'}

错误信息：${result.error || '未知错误'}

可能的原因：

API密钥不正确或已过期
网络连接问题
DeepSeek API服务暂时不可用
API调用次数已用完

`; } }, // 注意：最后一个方法后面不需要逗号 }; // 初始化AI题库模块 aiTikuModule.init(); setTimeout(() => { aiTikuModule.initAIInterface(); }, 1000); window.aiHelper = aiTikuModule; _w.confirm = (msg) => { return true; } setInterval(function () { _w.confirm = (msg) => { return true; } }, 2000); if (parseFloat(rate) == parseInt(rate)) { rate = parseInt(rate); } else { rate = parseFloat(rate); } try { _w.top.unrivalReviewMode = GM_getValue('unrivalreview', '0') || '1'; _w.top.unrivalDoWork = GM_getValue('unrivaldowork', '0') || '1'; _w.top.unrivalAutoSubmit = GM_getValue('unrivalautosubmit', '0') || '1'; _w.top.unrivalAutoSave = GM_getValue('unrivalautosave', '0') || '1'; } catch (e) { console.error('❌ 状态初始化失败:', e); } if (_l.href.indexOf("knowledge/cards") > 0) { let allowBackground = false, spans = _d.getElementsByTagName('span'); for (let i = 0, l = spans.length; i < l; i++) { if (spans[i].innerHTML.indexOf('章节未开放') != -1) { if (_l.href.indexOf("ut=s") != -1) { _l.href = _l.href.replace("ut=s", "ut=t").replace(/&cpi=[0-9]{1,10}/, ''); } else if (_l.href.indexOf("ut=t") != -1) { spans[i].innerHTML = '此课程为闯关模式，请回到上一章节完成学习任务！' return; } break; } } _w.top.unrivalPageRd = String(Math.random()); if (!isFf) { try { cVersion = parseInt(navigator.userAgent.match(/Chrome\/[0-9]{2,3}./)[0].replace('Chrome/', '') .replace('.', '')); } catch (e) { } } var busyThread = 0, getStr = (str, start, end) => { let res = str.substring(str.indexOf(start), str.indexOf(end)).replace(start, ''); return res; }, scripts = _d.getElementsByTagName('script'), param = null; for (let i = 0, l = scripts.length; i < l; i++) { if (scripts[i].innerHTML.indexOf('mArg = "";') != -1 && scripts[i].innerHTML.indexOf( '==UserScript==') == -1) { param = getStr(scripts[i].innerHTML, 'try{\n mArg = ', ';\n}catch(e){'); } } if (param == null) { return; } try { vrefer = _d.getElementsByClassName('ans-attach-online ans-insertvideo-online')[0].src; } catch (e) { vrefer = _p + '//' + _h + '/ananas/modules/video/index.html?v=2022-1118-1729'; } GM_setValue('vrefer', vrefer); GM_setValue('host', _h); var tikutoken=GM_getValue("tikutoken") if(tikutoken==null){ tikutoken="" } var base222 = `data:image/jpeg;base64,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` _d.getElementsByTagName("html")[0].innerHTML = ` 学习通小助手 v1.0

作者留言

🙏 你我想见即是缘分，今日我献上此宝，解道友之忧，虽是凡品

切勿介意,同时我也恳请道友赠予小友我一些机缘，大不言谢。

🐛 Bug反馈: new7966@163.com

🎓 祝大家学业有成！我有幸同行

任务配置

注意: 高倍速会清进度，建议一倍速运行，除非真的没时间才调高倍数

视频设置

视频倍速: 保存复习模式后台挂机激活挂机

章节测试

答题控制: 自动答题自动提交自动保存

正确率阈值: % 保存正确率达标且允许自动提交时才会提交答案

题库配置

AI 题库设置

启用AI题库

DeepSeek API密钥: 保存

测试AI连接清除AI缓存

提示: 后续版本将对接更多题库以提高准确率

任务列表

暂无任务...

运行日志

[00:00:00] 如果此提示不消失，说明页面出现了错误，请联系作者

清空日志

章节测试关闭

学习进度关闭

`; var logs = { "logArry": [], "addLog": function (str, color = "black") { if (this.logArry.length >= 50) { this.logArry.splice(0, 1); } var nowTime = new Date(); var nowHour = (Array(2).join(0) + nowTime.getHours()).slice(-2); var nowMin = (Array(2).join(0) + nowTime.getMinutes()).slice(-2); var nowSec = (Array(2).join(0) + nowTime.getSeconds()).slice(-2); this.logArry.push("[" + nowHour + ":" + nowMin + ":" + nowSec + "] " + str + ""); let logStr = ""; for (let logI = 0, logLen = this.logArry.length; logI < logLen; logI++) { logStr += this.logArry[logI] + "
"; } _d.getElementById('log').innerHTML = logStr; var logElement = _d.getElementById('log'); logElement.scrollTop = logElement.scrollHeight; } }, htmlHook = setInterval(function () { if (_d.getElementById('unrivalRate') && _d.getElementById('updateRateButton') && _d .getElementById('reviewModeButton') && _d.getElementById('autoDoWorkButton') && _d .getElementById('autoSubmitButton') && _d.getElementById('autoSaveButton')) { if (!enableBackground) { _d.getElementById('fuckMeModeButton').style.display = "none"; } allowBackground = Math.round(new Date() / 1000) - parseInt(GM_getValue( 'unrivalBackgroundVideoEnable', '6')) < 15; if (allowBackground) { _d.getElementById('fuckMeModeButton').setAttribute('href', 'unrivalxxtbackground/'); } clearInterval(htmlHook); if (cVersion < 86) { logs.addLog( '\u60a8\u7684\u6d4f\u89c8\u5668\u5185\u6838\u8fc7\u8001\uff0c\u8bf7\u66f4\u65b0\u7248\u672c\u6216\u4f7f\u7528\u4e3b\u6d41\u6d4f\u89c8\u5668\uff0c\u63a8\u8350\u003c\u0061\u0020\u0068\u0072\u0065\u0066\u003d\u0022\u0068\u0074\u0074\u0070\u0073\u003a\u002f\u002f\u0077\u0077\u0077\u002e\u006d\u0069\u0063\u0072\u006f\u0073\u006f\u0066\u0074\u002e\u0063\u006f\u006d\u002f\u007a\u0068\u002d\u0063\u006e\u002f\u0065\u0064\u0067\u0065\u0022\u0020\u0074\u0061\u0072\u0067\u0065\u0074\u003d\u0022\u0076\u0069\u0065\u0077\u005f\u0077\u0069\u006e\u0064\u006f\u0077\u0022\u003e\u0065\u0064\u0067\u0065\u6d4f\u89c8\u5668\u003c\u002f\u0061\u003e', 'red'); stop = true; return; } if (isMobile) { logs.addLog('手机浏览器不保证能正常运行此脚本', 'orange'); } _d.addEventListener('visibilitychange', function () { let isH = _d.hidden; if (!isH) { logs.addLog('挂机功能不稳定，不建议长时间最小化窗口', 'orange'); } }); // 委托给document或父元素 document.addEventListener('click', function(event) { if (event.target && event.target.id === 'toggleAI') { const aiSection = document.getElementById('aiConfigSection'); const aiStatus = document.getElementById('aiStatus'); if (aiSection.style.display === 'none') { aiSection.style.display = 'block'; aiStatus.textContent = '已展开'; aiStatus.style.color = 'green'; } else { aiSection.style.display = 'none'; aiStatus.textContent = '未启用'; aiStatus.style.color = 'red'; } } }); _d.getElementById('saveDeepseekKey').onclick = function () { const apiKey = _d.getElementById('deepseekKey').value.trim(); if (apiKey) { // 清除可能存在的空白字符 const cleanedKey = apiKey.replace(/\s+/g, ''); // 检查密钥格式 - 放宽长度检查 if (!cleanedKey.startsWith('sk-')) { logs.addLog('API密钥格式错误：必须以 "sk-" 开头', 'red'); alert('API密钥格式错误：必须以 "sk-" 开头'); return; } // 放宽长度检查：DeepSeek API密钥通常在40-60字符之间 if (cleanedKey.length < 30 || cleanedKey.length > 200) { logs.addLog(`API密钥长度异常 (${cleanedKey.length} 字符)，请检查是否正确复制`, 'red'); alert(`API密钥长度异常 (${cleanedKey.length} 字符)，请检查是否正确复制`); return; } // 保存密钥 GM_setValue('deepseekApiKey', cleanedKey); aiTikuModule.config.apiKey = cleanedKey; logs.addLog('DeepSeek API密钥已保存', 'green'); logs.addLog(`密钥长度：${cleanedKey.length} 字符`, 'green'); logs.addLog(`密钥前10位：${cleanedKey.substring(0, 10)}...`, 'green'); logs.addLog(`密钥后4位：${cleanedKey.substring(cleanedKey.length - 4)}`, 'green'); // 测试新密钥 setTimeout(() => { logs.addLog('正在测试新密钥...', 'blue'); aiTikuModule.testConnection(); }, 1000); } else { logs.addLog('请输入有效的API密钥', 'red'); } }; _d.getElementById('enableAI').checked = GM_getValue('enableAI', true); _d.getElementById('enableAI').onchange = function () { GM_setValue('enableAI', this.checked); logs.addLog('AI题库功能已' + (this.checked ? '启用' : '禁用'), 'green'); }; _d.getElementById('testAI').onclick = function () { logs.addLog('正在测试AI连接...', 'blue'); aiTikuModule.testConnection(); // 或者调用专门的测试函数 }; _d.getElementById('clearAICache').onclick = function () { // 简化的清除缓存方法 logs.addLog('正在清除AI缓存...', 'blue'); // 清除已知的AI缓存键 const keysToClear = [ 'ai_tiku_cache', 'deepseekApiKey', 'enableAI' ]; let clearedCount = 0; keysToClear.forEach(key => { try { GM_deleteValue(key); clearedCount++; } catch (e) { // 忽略错误 } }); logs.addLog(`已清除 ${clearedCount} 个AI相关设置`, 'green'); logs.addLog('注意：无法完全清除所有AI缓存，建议刷新页面重新开始', 'orange'); }; // 加载保存的API密钥 const savedApiKey = GM_getValue('deepseekApiKey', ''); if (savedApiKey) { _d.getElementById('deepseekKey').value = savedApiKey; } _d.getElementById('accuracy').value=accuracy; _d.getElementById('updateaccuracy').onclick = function () { var uaccuracy = _d.getElementById('accuracy').value; if (parseFloat(uaccuracy) == parseInt(uaccuracy)) { uaccuracy = parseInt(uaccuracy); } else { uaccuracy = parseFloat(uaccuracy); } GM_setValue('accuracy', uaccuracy); accuracy = uaccuracy; if (uaccuracy >= 0 && uaccuracy<=100) { logs.addLog('章节测试正确率已更新为'+uaccuracy+'%，将在3秒内生效', 'green'); } else { logs.addLog('奇怪正确率', 'orange'); } } _d.getElementById('unrivalRate').value = rate; _d.getElementById('updateRateButton').onclick = function () { let urate = _d.getElementById('unrivalRate').value; if (parseFloat(urate) == parseInt(urate)) { urate = parseInt(urate); } else { urate = parseFloat(urate); } GM_setValue('unrivalrate', urate); rate = urate; if (urate > 0) { logs.addLog('视频倍速已更新为' + urate + '倍，将在3秒内生效', 'green'); } else { logs.addLog('奇怪的倍速，将会自动跳过视频任务', 'orange'); } } _d.getElementById('backGround').onclick = function () { console.log(123) logs.addLog('挂机激活成功，您现在可以最小化页面了', 'green'); _d.getElementById('backGround').setAttribute('class', 'btn btn-success'); _w.top.backNow = 1; } _d.getElementById('reviewModeButton').onclick = function () { let reviewButton = _d.getElementById('reviewModeButton'); if (reviewButton.getAttribute('class') == 'btn btn-default') { _d.getElementById('reviewModeButton').setAttribute('class', 'btn btn-success'); logs.addLog('复习模式已开启，遇到已完成的视频任务不会跳过', 'green'); GM_setValue('unrivalreview', '1'); _w.top.unrivalReviewMode = '1'; } else { _d.getElementById('reviewModeButton').setAttribute('class', 'btn btn-default'); logs.addLog('复习模式已关闭，遇到已完成的视频任务会自动跳过', 'green'); GM_setValue('unrivalreview', '0'); _w.top.unrivalReviewMode = '0'; } } _d.getElementById('autoDoWorkButton').onclick = function () { let autoDoWorkButton = _d.getElementById('autoDoWorkButton'); if (autoDoWorkButton.getAttribute('class') == 'btn btn-default') { _d.getElementById('autoDoWorkButton').setAttribute('class', 'btn btn-success'); logs.addLog('自动做章节测试已开启，将会自动做章节测试', 'green'); GM_setValue('unrivaldowork', '1'); _w.top.unrivalDoWork = '1'; } else { _d.getElementById('autoDoWorkButton').setAttribute('class', 'btn btn-default'); logs.addLog('自动做章节测试已关闭，将不会自动做章节测试', 'green'); GM_setValue('unrivaldowork', '0'); _w.top.unrivalDoWork = '0'; } } _d.getElementById('autoSubmitButton').onclick = function () { let autoSubmitButton = _d.getElementById('autoSubmitButton'); if (autoSubmitButton.getAttribute('class') == 'btn btn-default') { _d.getElementById('autoSubmitButton').setAttribute('class', 'btn btn-success'); logs.addLog('符合提交标准的章节测试将会自动提交', 'green'); GM_setValue('unrivalautosubmit', '1'); _w.top.unrivalAutoSubmit = '1'; } else { _d.getElementById('autoSubmitButton').setAttribute('class', 'btn btn-default'); logs.addLog('章节测试将不会自动提交', 'green'); GM_setValue('unrivalautosubmit', '0'); _w.top.unrivalAutoSubmit = '0'; } } _d.getElementById('autoSaveButton').onclick = function () { let autoSaveButton = _d.getElementById('autoSaveButton'); if (autoSaveButton.getAttribute('class') == 'btn btn-default') { _d.getElementById('autoSaveButton').setAttribute('class', 'btn btn-success'); logs.addLog('不符合提交标准的章节测试将会自动保存', 'green'); GM_setValue('unrivalautosave', '1'); _w.top.unrivalAutoSave = '1'; } else { _d.getElementById('autoSaveButton').setAttribute('class', 'btn btn-default'); logs.addLog('不符合提交标准的章节测试将不会自动保存，等待用户自己操作', 'green'); GM_setValue('unrivalautosave', '0'); _w.top.unrivalAutoSave = '0'; } } /* _d.getElementById('videoTimeButton').onclick = function () { _d.getElementById('videoTime').style.display = 'block'; _d.getElementById('videoTimeContent').src = _p + '//stat2-ans.chaoxing.com/task/s/index?courseid=' + courseId + '&clazzid=' + classId; }*/ } }, 100), loopjob = () => { if (_w.top.unrivalScriptList.length > 1) { logs.addLog('您同时开启了多个刷课脚本，会挂科，会挂科，会挂科，会挂科，会挂科，会挂科，会挂科，会挂科', 'red'); } if (cVersion < 8.6 * 10) { logs.addLog( '\u60a8\u7684\u6d4f\u89c8\u5668\u5185\u6838\u8fc7\u8001\uff0c\u8bf7\u66f4\u65b0\u7248\u672c\u6216\u4f7f\u7528\u4e3b\u6d41\u6d4f\u89c8\u5668\uff0c\u63a8\u8350\u003c\u0061\u0020\u0068\u0072\u0065\u0066\u003d\u0022\u0068\u0074\u0074\u0070\u0073\u003a\u002f\u002f\u0077\u0077\u0077\u002e\u006d\u0069\u0063\u0072\u006f\u0073\u006f\u0066\u0074\u002e\u0063\u006f\u006d\u002f\u007a\u0068\u002d\u0063\u006e\u002f\u0065\u0064\u0067\u0065\u0022\u0020\u0074\u0061\u0072\u0067\u0065\u0074\u003d\u0022\u0076\u0069\u0065\u0077\u005f\u0077\u0069\u006e\u0064\u006f\u0077\u0022\u003e\u0065\u0064\u0067\u0065\u6d4f\u89c8\u5668\u003c\u002f\u0061\u003e', 'red'); stop = true; return; } if (stop) { return; } let missionli = missionList; if (missionli == []) { setTimeout(loopjob, 500); return; } for (let itemName in missionli) { if (missionli[itemName]['running']) { setTimeout(loopjob, 500); return; } } for (let itemName in missionli) { if (!missionli[itemName]['done']) { switch (missionli[itemName]['type']) { case 'video': doVideo(missionli[itemName]); break; case 'document': doDocument(missionli[itemName]); break; case 'work': doWork(missionli[itemName]); break; } setTimeout(loopjob, 500); return; } } if (busyThread <= 0) { if (jumpType != 2) { _w.top.jump = true; logs.addLog('所有任务处理完毕，5秒后自动下一章', 'green'); } else { logs.addLog('所有任务处理完毕，用户设置为不跳转，脚本已结束运行，如需自动跳转，请编辑脚本代码参数', 'green'); } clearInterval(loopjob); } else { setTimeout(loopjob, 500); } }, readyCheck = () => { setTimeout(function () { try { if (!isCat) { logs.addLog( '推荐使用脚本猫运行此脚本，使用其他脚本管理器不保证能正常运行', 'orange'); } if (_w.top.unrivalReviewMode == '1') { logs.addLog('复习模式已开启，遇到已完成的视频任务不会跳过', 'green'); _d.getElementById('reviewModeButton').setAttribute('class', ['btn btn-default', 'btn btn-success' ][_w.top.unrivalReviewMode]); } if (_w.top.unrivalDoWork == '1') { logs.addLog('自动做章节测试已开启，将会自动做章节测试', 'green'); _d.getElementById('autoDoWorkButton').setAttribute('class', ['btn btn-default', 'btn btn-success' ][_w.top.unrivalDoWork]); } _d.getElementById('autoSubmitButton').setAttribute('class', ['btn btn-default', 'btn btn-success' ][_w.top.unrivalAutoSubmit]); _d.getElementById('autoSaveButton').setAttribute('class', ['btn btn-default', 'btn btn-success' ][_w.top.unrivalAutoSave]); } catch (e) { console.log(e); readyCheck(); return; } }, 500); } readyCheck(); try { var pageData = JSON.parse(param); } catch (e) { if (jumpType != 2) { _w.top.jump = true; logs.addLog('此页无任务，5秒后自动下一章', 'green'); } else { logs.addLog('此页无任务，用户设置为不跳转，脚本已结束运行，如需自动跳转，请编辑脚本代码参数', 'green'); } return; } var data = pageData['defaults'], jobList = [], classId = data['clazzId'], chapterId = data['knowledgeid'], reportUrl = data['reportUrl'], ktoken = data['ktoken']; UID = UID || data['userid']; FID = FID || data['fid']; for (let i = 0, l = pageData['attachments'].length; i < l; i++) { let item = pageData['attachments'][i]; if (item['job'] != true || item['isPassed'] == true) { if (_w.top.unrivalReviewMode == '1' && item['type'] == 'video') { jobList.push(item); } continue; } else { jobList.push(item); } } var video_getReady = (item) => { let statusUrl = _p + '//' + _h + '/ananas/status/' + item['property']['objectid'] + '?k=' + FID + '&flag=normal&_dc=' + String(Math.round(new Date())), doubleSpeed = item['property']['doublespeed']; busyThread += 1; GM_xmlhttpRequest({ method: "get", headers: { 'Host': _h, 'Referer': vrefer, 'Sec-Fetch-Site': 'same-origin' }, url: statusUrl, onload: function (res) { try { busyThread -= 1; let videoInfo = JSON.parse(res.responseText), duration = videoInfo['duration'], dtoken = videoInfo['dtoken']; if (duration == undefined) { _d.getElementById('joblist').innerHTML += `

` + '[无效视频]' + item['property']['name'] + `

` return; } missionList['m' + item['jobid']] = { 'module': item['property']['module'], 'type': 'video', 'dtoken': dtoken, 'duration': duration, 'objectId': item['property']['objectid'], 'rt': item['property']['rt'] || '0.9', 'otherInfo': item['otherInfo'], 'doublespeed': doubleSpeed, 'jobid': item['jobid'], 'name': item['property']['name'], 'done': false, 'running': false }; _d.getElementById('joblist').innerHTML += `

` + '[视频]' + item['property']['name'] + `

` } catch (e) { } }, onerror: function (err) { console.log(err); if (err.error.indexOf('@connect list') >= 0) { logs.addLog('请添加安全网址，将【 //@connect ' + _h + ' 】方括号里的内容(不包括方括号)添加到脚本代码内指定位置，否则脚本无法正常运行，如图所示：', 'red'); logs.addLog( '

','red' ); stop = true; } else { logs.addLog('获取任务详情失败', 'red'); logs.addLog('错误原因：' + err.error, 'red'); } } }); }, doVideo = (item) => { if (rate <= 0) { missionList['m' + item['jobid']]['running'] = true; logs.addLog('奇怪的倍速，视频已自动跳过', 'orange'); setTimeout(function () { missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; }, 5000); return; } if (allowBackground && enableBackground) { if (_w.top.document.getElementsByClassName('catalog_points_sa').length > 0 || _w.top.document .getElementsByClassName('lock').length > 0) { logs.addLog('您已安装超星挂机小助手，但此课程可能为闯关模式，不支持后台挂机，将为您在线完成', 'blue'); } else { item['userid'] = UID; item['classId'] = classId; item['review'] = [false, true][_w.top.unrivalReviewMode]; item['reportUrl'] = reportUrl; item['rt'] = missionList['m' + item['jobid']]['rt']; GM_setValue('unrivalBackgroundVideo', item); _d.cookie = "videojs_id=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;"; logs.addLog( '您已安装超星挂机小助手，已添加至后台任务，点我查看后台', 'green'); missionList['m' + item['jobid']]['running'] = true; setTimeout(function () { missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; }, 5000); return; } } let videojs_id = String(parseInt(Math.random() * 9999999)); _d.cookie = 'videojs_id=' + videojs_id + ';path=/' logs.addLog('开始刷视频：' + item['name'] + '，倍速：' + String(rate) + '倍','red'); logs.addLog('视频观看信息每60秒上报一次，请耐心等待', 'green'); logs.addLog('如遇脚本使用异常情况，请检查脚本版本是否为最新版，点我(脚本猫)或点我(greasyfork)检查', 'orange'); if (disableMonitor) { logs.addLog('解除多端学习监控有清除进度风险，请谨慎使用', 'orange'); } let dtype = 'Video'; if (item['module'].includes('audio')) { dtype = 'Audio'; rt = ''; } let playTime = 0, playsTime = 0, isdrag = '3', times = 0, encUrl = '', first = true, loop = setInterval(function () { if (rate <= 0) { clearInterval(loop); logs.addLog('奇怪的倍速，视频已自动跳过', 'orange'); setTimeout(function () { missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; }, 5000); return; } else if (item['doublespeed'] == 0 && rate > 1 && _w.top.unrivalReviewMode == '0') { //rate = 1; //logs.addLog('该视频不允许倍速播放，已恢复至一倍速，高倍速会被清空进度挂科，勿存侥幸', 'red'); } rt = missionList['m' + item['jobid']]['rt']; playsTime += rate; playTime = Math.ceil(playsTime); if (times == 0 || times % 30 == 0 || playTime >= item['duration']) { if (first) { playTime = 0; } if (playTime >= item['duration']) { clearInterval(loop); playTime = item['duration']; isdrag = '4'; } else if (playTime > 0) { isdrag = '0'; } encUrl = host + 'chaoXing/v3/getEnc.php?classid=' + classId + '&playtime=' + playTime + '&duration=' + item['duration'] + '&objectid=' + item[ 'objectId'] + '&jobid=' + item['jobid'] + '&uid=' + UID; busyThread += 1; var _bold_playTime = playTime; function ecOnload(res) { let enc = ''; if (res && res.status == 200) { enc = res.responseText; if (enc.includes('--#')) { let warnInfo = enc.match(new RegExp('--#(.*?)--#', "ig"))[0] .replace(/--#/ig, ''); logs.addLog(warnInfo, 'red'); enc = enc.replace(/--#(.*?)--#/ig, ''); } if (enc.indexOf('.stop') >= 0) { clearInterval(loop); stop = true; return; } } else { strEc = `[${classId}][${UID}][${item['jobid']}][${item['objectId']}][${playTime * 1000}][d_yHJ!$pdA~5][${item['duration'] * 1000}][0_${item['duration']}]`, enc = jq.md5(strEc); } if (enc.length != 32) { clearInterval(loop); stop = true; return; } let reportsUrl = reportUrl + '/' + item['dtoken'] + '?clazzId=' + classId + '&playingTime=' + playTime + '&duration=' + item['duration'] + '&clipTime=0_' + item[ 'duration'] + '&objectId=' + item['objectId'] + '&otherInfo=' + item['otherInfo'] + '&jobid=' + item[ 'jobid'] + '&userid=' + UID + '&isdrag=' + isdrag + '&view=pc&enc=' + enc + '&rt=' + rt + '&dtype=' + dtype + '&_t=' + String(Math.round(new Date())); GM_xmlhttpRequest({ method: "get", headers: { 'Host': _h, 'Referer': vrefer, 'Sec-Fetch-Site': 'same-origin', 'Content-Type': 'application/json' }, url: reportsUrl, onload: function (res) { try { let today = new Date(), todayStr = today.getFullYear() + 'd' + today.getMonth() + 'd' + today .getDate(), timelong = GM_getValue( 'unrivaltimelong', {}); if (timelong[UID] == undefined || timelong[UID]['today'] != todayStr ) { timelong[UID] = { 'time': 0, 'today': todayStr }; } else { timelong[UID]['time']++; } GM_setValue('unrivaltimelong', timelong); busyThread -= 1; if (timelong[UID]['time'] / 60 > 22 && item['doublespeed'] == 0 && _w.top .unrivalReviewMode == '0') { clearInterval(loop); logs.addLog( '今日学习时间过长，继续学习会导致清空进度，请明天再来', 'red'); setTimeout(function () { missionList['m' + item[ 'jobid']][ 'running' ] = false; missionList['m' + item[ 'jobid']][ 'done' ] = true; }, 5000); return; } let ispass = JSON.parse(res .responseText); first = false; if (ispass['isPassed'] && _w.top .unrivalReviewMode == '0') { logs.addLog('视频任务已完成', 'green'); missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; clearInterval(loop); return; } else if (isdrag == '4') { if (_w.top.unrivalReviewMode == '1') { logs.addLog('视频已观看完毕', 'green'); } else { logs.addLog('视频已观看完毕，但视频任务未完成', 'red'); } missionList['m' + item['jobid']][ 'running' ] = false; missionList['m' + item['jobid']][ 'done' ] = true; try { clearInterval(loop); } catch (e) { } } else { logs.addLog(item['name'] + '已观看' + _bold_playTime + '秒，剩余大约' + String(item['duration'] - _bold_playTime) + '秒','red'); } } catch (e) { console.log(e); if (res.responseText.indexOf('验证码') >= 0) { logs.addLog('已被超星风控，请点我处理，60秒后自动刷新页面', 'red'); missionList['m' + item['jobid']][ 'running' ] = false; clearInterval(loop); stop = true; setTimeout(function () { _l.reload(); }, 60000); return; } logs.addLog('超星返回错误信息，十秒后重试', 'red'); times = -10; return; } }, onerror: function (err) { console.log(err); if (err.error.indexOf('@connect list') >= 0) { logs.addLog( '请添加安全网址，将【 //@connect ' + _h + ' 】方括号里的内容(不包括方括号)添加到脚本代码内指定位置，否则脚本无法正常运行，如图所示：', 'red'); logs.addLog( '

','red' ); stop = true; } else { logs.addLog('观看视频失败', 'red'); logs.addLog('错误原因：' + err.error, 'red'); } missionList['m' + item['jobid']][ 'running' ] = false; clearInterval(loop); } }); }; GM_xmlhttpRequest({ method: "get", url: encUrl, timeout: 2000, onload: ecOnload, onerror: function (err) { console.log(err); ecOnload(false); }, ontimeout: function (err) { console.log(err); ecOnload(false); } }); } times += 1; }, 1000); missionList['m' + item['jobid']]['running'] = true; }, doDocument = (item) => { missionList['m' + item['jobid']]['running'] = true; logs.addLog('开始刷文档：' + item['name'],'red'); setTimeout(function () { busyThread += 1; GM_xmlhttpRequest({ method: "get", url: _p + '//' + _h + '/ananas/job/document?jobid=' + item['jobid'] + '&knowledgeid=' + chapterId + '&courseid=' + courseId + '&clazzid=' + classId + '&jtoken=' + item['jtoken'], onload: function (res) { try { busyThread -= 1; let ispass = JSON.parse(res.responseText); if (ispass['status']) { logs.addLog('文档任务已完成', 'green'); } else { logs.addLog('文档已阅读完成，但任务点未完成', 'red'); } } catch (err) { console.log(err); console.log(res.responseText); logs.addLog('解析文档内容失败', 'red'); } missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; }, onerror: function (err) { console.log(err); if (err.error.indexOf('@connect list') >= 0) { logs.addLog('请添加安全网址，将【 //@connect ' + _h + ' 】方括号里的内容(不包括方括号)添加到脚本代码内指定位置，否则脚本无法正常运行，如图所示：', 'red'); logs.addLog( '

' ); stop = true; } else { logs.addLog('阅读文档失败', 'red'); logs.addLog('错误原因：' + err.error, 'red'); } missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; } }); }, parseInt(Math.random() * 2000 + 9000, 10)) }, doWork = (item) => { missionList['m' + item['jobid']]['running'] = true; logs.addLog('开始刷章节测试：' + item['name'],'red'); logs.addLog('您设置的答题正确率为：' + String(accuracy) + '%，只有在高于此正确率时才会提交测试', 'blue'); _d.getElementById('workPanel').style.display = 'block'; _d.getElementById('frame_content').src = _p + '//' + _h + '/work/phone/work?workId=' + item['jobid'] .replace('work-', '') + '&courseId=' + courseId + '&clazzId=' + classId + '&knowledgeId=' + chapterId + '&jobId=' + item['jobid'] + '&enc=' + item['enc']; _w.top.unrivalWorkInfo = ''; _w.top.unrivalDoneWorkId = ''; setInterval(function () { if (_w.top.unrivalWorkInfo != '') { logs.addLog(_w.top.unrivalWorkInfo,'red'); _w.top.unrivalWorkInfo = ''; } }, 100); let checkcross = setInterval(function () { if (_w.top.unrivalWorkDone == false) { clearInterval(checkcross); return; } let ifW = _d.getElementById('frame_content').contentWindow; try { ifW.location.href; } catch (e) { console.log(e); if (e.message.indexOf('cross-origin') != -1) { clearInterval(checkcross); _w.top.unrivalWorkDone = true; return; } } }, 2000); let workDoneInterval = setInterval(function () { if (_w.top.unrivalWorkDone) { _w.top.unrivalWorkDone = false; clearInterval(workDoneInterval); _w.top.unrivalDoneWorkId = ''; _d.getElementById('workPanel').style.display = 'none'; _d.getElementById('frame_content').src = ''; setTimeout(function () { missionList['m' + item['jobid']]['running'] = false; missionList['m' + item['jobid']]['done'] = true; }, 5000); } }, 500); }, missionList = []; if (jobList.length <= 0) { if (jumpType != 2) { _w.top.jump = true; logs.addLog('此页无任务，5秒后自动下一章', 'green'); } else { logs.addLog('此页无任务，用户设置为不跳转，脚本已结束运行，如需自动跳转，请编辑脚本代码参数', 'green'); } return; } for (let i = 0, l = jobList.length; i < l; i++) { let item = jobList[i]; if (item['type'] == 'video') { video_getReady(item); } else if (item['type'] == 'document') { missionList['m' + item['jobid']] = { 'type': 'document', 'jtoken': item['jtoken'], 'jobid': item['jobid'], 'name': item['property']['name'], 'done': false, 'running': false }; _d.getElementById('joblist').innerHTML += `

` + '[文档]' + item['property']['name'] + `

` } else if (item['type'] == 'workid' && _w.top.unrivalDoWork == '1') { missionList['m' + item['jobid']] = { 'type': 'work', 'workid': item['property']['workid'], 'jobid': item['jobid'], 'name': item['property']['title'], 'enc': item['enc'], 'done': false, 'running': false }; _d.getElementById('joblist').innerHTML += `

` + '[章节测试]' + item['property']['title'] + `

` } else { try { let jobName = item['property']['name']; if (jobName == undefined) { jobName = item['property']['title']; } _d.getElementById('joblist').innerHTML += `

` + '已跳过：' + jobName + `

` } catch (e) { } } } loopjob(); } else if (_l.href.includes("mycourse/studentstudy")) { var audiofile = 'data:audio/ogg;base64,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', audioPlayer = new Audio(audiofile); _w.top.backNow = 0; audioPlayer.loop = true; _w.audioPlayer = audioPlayer; setInterval(function () { try { _w.jQuery.fn.viewer.Constructor.prototype.show = () => { }; } catch (e) {} }, 1000); try { _w.unrivalScriptList.push('Fuck me please'); } catch (e) { _w.unrivalScriptList = ['Fuck me please']; } function checkOffline() { let dleft = _d.getElementsByClassName('left'); if (dleft.length == 1) { let img = dleft[0].getElementsByTagName('img'); if (img.length == 1) { if (img[0].src.indexOf('loading.gif') != -1) { return true; } } } return false; } setInterval(function () { if (checkOffline()) { setTimeout(function () { if (checkOffline()) { _l.reload(); } }, 10000) } }, 3000); _d.addEventListener('visibilitychange', function () { var c = 0; if (_w.top.backNow == 0) { _d.title = '⚠️请先激活挂机'; return } else { _d.title = '学生学习页面'; } if (_d.hidden) { audioPlayer.play(); var timer = setInterval(function () { if (c) { _d.title = '🙈挂机中'; c = 0; } else { _d.title = '🙉挂机中'; c = 1; } if (!_d.hidden) { clearInterval(timer); _d.title = '学生学习页面'; } }, 1300); } else { audioPlayer.pause(); } }); _d.addEventListener('click', function(event) { const target = event.target; // 处理AI测试按钮点击 if (target && (target.id === 'testAI' || target.closest('#testAI'))) { event.preventDefault(); event.stopPropagation(); logs.addLog('正在测试AI连接...', 'blue'); // 测试连接 aiTikuModule.testConnection(); return; } // 处理保存API密钥按钮点击 if (target && (target.id === 'saveDeepseekKey' || target.closest('#saveDeepseekKey'))) { event.preventDefault(); event.stopPropagation(); const apiKey = _d.getElementById('deepseekKey').value.trim(); if (apiKey) { aiTikuModule.saveApiKey(apiKey); logs.addLog('DeepSeek API密钥已保存', 'green'); // 立即更新配置 aiTikuModule.config.apiKey = apiKey; } else { logs.addLog('请输入有效的API密钥', 'red'); } return; } }); // 初始化AI接口 setTimeout(() => { // 检查是否有保存的API密钥 const savedApiKey = GM_getValue('deepseekApiKey', ''); if (savedApiKey && _d.getElementById('deepseekKey')) { _d.getElementById('deepseekKey').value = savedApiKey; aiTikuModule.config.apiKey = savedApiKey; logs.addLog('已加载保存的DeepSeek API密钥', 'green'); } // 初始化AI配置界面 if (_d.getElementById('enableAI')) { _d.getElementById('enableAI').checked = GM_getValue('enableAI', true); } }, 1500); _w.unrivalgetTeacherAjax = _w.getTeacherAjax; _w.getTeacherAjax = (courseid, classid, cid) => { if (cid == getQueryVariable('chapterId')) { return; } _w.top.unrivalPageRd = ''; _w.unrivalgetTeacherAjax(courseid, classid, cid); } if (disableMonitor == 1) { _w.appendChild = _w.Element.prototype.appendChild; _w.Element.prototype.appendChild = function () { try { if (arguments[0].src.indexOf('detect.chaoxing.com') > 0) { return; } } catch (e) { } _w.appendChild.apply(this, arguments); }; } _w.jump = false; setInterval(function () { if (getQueryVariable('mooc2') == '1') { let tabs = _d.getElementsByClassName('posCatalog_select'); for (let i = 0, l = tabs.length; i < l; i++) { let tabId = tabs[i].getAttribute('id'); if (tabId.indexOf('cur') >= 0 && tabs[i].getAttribute('class') == 'posCatalog_select') { tabs[i].setAttribute('onclick', "getTeacherAjax('" + courseId + "','" + classId + "','" + tabId.replace('cur', '') + "');"); } } } else { let h4s = _d.getElementsByTagName('h4'), h5s = _d.getElementsByTagName('h5'); for (let i = 0, l = h4s.length; i < l; i++) { if (h4s[i].getAttribute('id').indexOf('cur') >= 0) { h4s[i].setAttribute('onclick', "getTeacherAjax('" + courseId + "','" + classId + "','" + h4s[i].getAttribute('id').replace('cur', '') + "');"); } } for (let i = 0, l = h5s.length; i < l; i++) { if (h5s[i].getAttribute('id').indexOf('cur') >= 0) { h5s[i].setAttribute('onclick', "getTeacherAjax('" + courseId + "','" + classId + "','" + h5s[i].getAttribute('id').replace('cur', '') + "');"); } } } }, 1000); setInterval(function () { let but = null; if (_w.jump) { _w.jump = false; _w.top.unrivalDoneWorkId = ''; _w.jjump = (rd) => { if (rd != _w.top.unrivalPageRd) { return; } try { setTimeout(function () { if (jumpType == 1) { if (getQueryVariable('mooc2') == '1') { but = _d.getElementsByClassName( 'jb_btn jb_btn_92 fs14 prev_next next'); } else { but = _d.getElementsByClassName('orientationright'); } try { setTimeout(function () { if (rd != _w.top.unrivalPageRd) { return; } but[0].click(); }, 2000); } catch (e) { } return; } if (getQueryVariable('mooc2') == '1') { let ul = _d.getElementsByClassName('prev_ul')[0], lis = ul.getElementsByTagName('li'); for (let i = 0, l = lis.length; i < l; i++) { if (lis[i].getAttribute('class') == 'active') { if (i + 1 >= l) { break; } else { try { lis[i + 1].click(); } catch (e) { } return; } } } let tabs = _d.getElementsByClassName('posCatalog_select'); for (let i = 0, l = tabs.length; i < l; i++) { if (tabs[i].getAttribute('class') == 'posCatalog_select posCatalog_active') { while (i + 1 < tabs.length) { let nextTab = tabs[i + 1]; if ((nextTab.innerHTML.includes( 'icon_Completed prevTips') && _w.top .unrivalReviewMode == '0') || nextTab .innerHTML.includes( 'catalog_points_er prevTips')) { i++; continue; } if (nextTab.id.indexOf('cur') < 0) { i++; continue; } let clickF = setInterval(function () { if (rd != _w.top.unrivalPageRd) { clearInterval(clickF); return; } nextTab.click(); }, 2000); break; } break; } } } else { let div = _d.getElementsByClassName('tabtags')[0], spans = div.getElementsByTagName('span'); for (let i = 0, l = spans.length; i < l; i++) { if (spans[i].getAttribute('class').indexOf('currents') >= 0) { if (i + 1 == l) { break; } else { try { spans[i + 1].click(); } catch (e) { } return; } } } let tabs = _d.getElementsByTagName('span'), newTabs = []; for (let i = 0, l = tabs.length; i < l; i++) { if (tabs[i].getAttribute('style') != null && tabs[i] .getAttribute('style').indexOf( 'cursor:pointer;height:18px;') >= 0) { newTabs.push(tabs[i]); } } tabs = newTabs; for (let i = 0, l = tabs.length; i < l; i++) { if (tabs[i].parentNode.getAttribute('class') == 'currents') { while (i + 1 < tabs.length) { let nextTab = tabs[i + 1].parentNode; if ((nextTab.innerHTML.includes( 'roundpoint blue') && _w.top .unrivalReviewMode == '0') || nextTab .innerHTML.includes('roundpointStudent lock') ) { i++; continue; } if (nextTab.id.indexOf('cur') < 0) { i++; continue; } let clickF = setInterval(function () { if (rd != _w.top.unrivalPageRd) { clearInterval(clickF); return; } nextTab.click(); }, 2000); break; } break; } } } }, 2000); } catch (e) { } } _w.onReadComplete1(); setTimeout('jjump("' + _w.top.unrivalPageRd + '")', 2856); } }, 200); } else if (_l.href.indexOf("work/phone/doHomeWork") > 0) { var wIdE = _d.getElementById('workLibraryId') || _d.getElementById('oldWorkId'), wid = wIdE.value; _w.top.unrivalWorkDone = false; _w.aalert = _w.alert; _w.alert = (msg) => { if (msg == '保存成功') { _w.top.unrivalDoneWorkId = getQueryVariable('workId'); return; } aalert(msg); } if (_w.top.unrivalDoneWorkId == getQueryVariable('workId')) { _w.top.unrivalWorkDone = true; return; } _w.confirm = (msg) => { return true; } var questionList = [], questionsElement = _d.getElementsByClassName('Py-mian1'), questionNum = questionsElement.length, totalQuestionNum = questionNum; answeredCount = 0; for (let i = 0; i < questionNum; i++) { let questionElement = questionsElement[i], idElements = questionElement.getElementsByTagName('input'), questionId = '0', question = questionElement.getElementsByClassName('Py-m1-title fs16')[0].innerHTML; question = handleImgs(question).replace(/(<([^>]+)>)/ig, '').replace(/[0-9]{1,3}.\[(.*?)\]/ig, '').replaceAll('\n', '').replace(/^\s+/ig, '').replace(/\s+$/ig, ''); console.log('=== 题目解析 ==='); console.log(`第${i+1}个题目`); console.log('题目文本:', question.substring(0, 50)); console.log('题目元素中的input数量:', idElements.length); for (let z = 0, k = idElements.length; z < k; z++) { try { const inputName = idElements[z].getAttribute('name'); const inputId = idElements[z].getAttribute('id'); console.log(`输入框${z}: name="${inputName}", id="${inputId}"`); if (inputName && inputName.indexOf('answer') >= 0) { questionId = inputName.replace('type', ''); console.log('找到answer输入框，questionId =', questionId); break; } } catch (e) { console.log(e); continue; } } if (questionId == '0' || question == '') { console.log('题目ID为0或题目为空，跳过该题目'); continue; } typeE = questionElement.getElementsByTagName('input'); if (typeE == null || typeE == []) { console.log('题目元素中没有input，跳过该题目'); continue; } let typeN = 'fuckme'; console.log('查找题目类型输入框...'); for (let g = 0, h = typeE.length; g < h; g++) { const inputId = typeE[g].getAttribute('id'); const expectedId = 'answertype' + questionId.replace('answer', '').replace('check', ''); console.log(`检查输入框: id="${inputId}", 期望id="${expectedId}"`); if (inputId == expectedId) { typeN = typeE[g].value; console.log('找到题目类型输入框，typeN =', typeN); break; } } console.log('题目ID:', questionId, 'typeN:', typeN); if (['0', '1', '2', '3', '4'].indexOf(typeN) < 0) { console.log('题目类型无效，跳过该题目'); continue; } type = { '0': '单选题', '1': '多选题', '2': '填空题', '3': '判断题', '4': '简答题' }[typeN]; console.log('题目类型:', type); let optionList = { length: 0 }; if (['单选题', '多选题'].indexOf(type) >= 0) { let answersElements = questionElement.getElementsByClassName('answerList')[0].getElementsByTagName( 'li'); for (let x = 0, j = answersElements.length; x < j; x++) { let optionE = answersElements[x], optionTextE = trim(optionE.innerHTML.replace(/(^\s*)|(\s*$)/g, "")), optionText = optionTextE.slice(1).replace(/(^\s*)|(\s*$)/g, ""), optionValue = optionTextE.slice(0, 1), optionId = optionE.getAttribute('id-param'); if (optionText == '') { break; } optionList[optionText] = { 'id': optionId, 'value': optionValue } optionList.length++; } if (answersElements.length != optionList.length) { continue; } } else if (type === '填空题') { // 填空题不需要选项，直接处理 optionList = { length: 0 }; console.log('填空题被识别，将添加到questionList'); // 查找填空题输入框并打印详细信息 const blankInputs = questionElement.querySelectorAll('input[type="text"], textarea'); console.log('填空题输入框数量:', blankInputs.length); blankInputs.forEach((input, index) => { console.log(`填空题输入框${index + 1}:`, { tagName: input.tagName, type: input.type, name: input.getAttribute('name'), id: input.id, value: input.value }); }); } questionList.push({ 'question': question, 'type': type, 'questionid': questionId, 'options': optionList }); console.log('题目已添加到questionList:', { type: type, questionId: questionId, question: question.substring(0, 30) }); console.log('=================='); } var qu = null, nowTime = -4000, busyThread = questionList.length; var ctOnload = function (res, quu) { busyThread -= 1; var ctResult = { 'code': -1, 'finalUrl': '', 'data': '未找到答案' }; if (res) { try { var responseText = res.responseText; ctResult = JSON.parse(responseText); } catch (e) { console.log(e); if (res.finalUrl.includes('getAnswer.php')) { _w.top.unrivalWorkInfo = '查题错误，服务器连接失败'; return; } } } try { // 先获取AI配置状态 const isAIEnabled = GM_getValue('enableAI', true); const hasApiKey = GM_getValue('deepseekApiKey', '') || aiTikuModule.config.apiKey; // 调试信息 console.log('=== AI题库调用调试 ==='); console.log('题目:', quu['question'].substring(0, 50) + '...'); console.log('题库返回结果:', ctResult); console.log('AI功能启用:', isAIEnabled); console.log('API密钥存在:', !!hasApiKey); console.log('==================='); // 检查是否应该使用AI题库 const shouldUseAI = isAIEnabled && hasApiKey; if (shouldUseAI) { _w.top.unrivalWorkInfo = '尝试使用AI题库答题...'; // 准备题目数据 const questionForAI = { question: quu['question'], type: quu['type'], options: quu['options'], questionid: quu['questionid'] }; // 添加调试日志 console.log('=== 填空题处理调试 ==='); console.log('题目类型:', quu['type']); console.log('题目ID:', quu['questionid']); console.log('题目内容:', quu['question'].substring(0, 50)); console.log('选项:', quu['options']); console.log('======================='); // 调用AI处理 console.log('=== 开始调用AI题库 ==='); console.log('题目对象:', questionForAI); aiTikuModule.processQuestion(questionForAI) .then(aiResult => { console.log('=== AI处理结果 ==='); console.log('完整返回:', aiResult); console.log('aiAnswer:', aiResult.aiAnswer); console.log('aiAnalysis:', aiResult.aiAnalysis); if (aiResult.aiAnswer && aiResult.aiAnswer !== '未找到答案') { console.log('✓ AI找到有效答案，使用AI答案'); _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：AI答案：' + aiResult.aiAnswer; // 显示AI解析（简答题不显示解析） if (aiResult.aiAnalysis && quu['type'] !== '简答题') { aiTikuModule.showAiAnalysis(quu['questionid'], aiResult.aiAnalysis, aiResult.aiAnswer); } // 应用答案 applyAnswer(quu, aiResult.aiAnswer); } else { console.log('✗ AI未找到有效答案'); // AI没找到答案，尝试使用题库答案 console.log('题库结果:', ctResult); if (ctResult['code'] == 1 && ctResult['data'] && ctResult['data'] !== '未找到答案') { console.log('✓ 题库找到答案，使用题库答案'); _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：题库答案：' + ctResult['data']; applyAnswer(quu, ctResult['data']); } else { console.log('✗ 题库也未找到答案，使用默认答案'); _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：AI和题库都未找到答案'; handleNoAnswer(quu); } } }) .catch(error => { console.error('=== AI题库处理失败 ==='); console.error('错误信息:', error); // AI失败时使用题库 console.log('题库结果:', ctResult); if (ctResult['code'] == 1 && ctResult['data'] && ctResult['data'] !== '未找到答案') { console.log('✓ 题库找到答案，使用题库答案'); _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：题库答案：' + ctResult['data']; applyAnswer(quu, ctResult['data']); } else { console.log('✗ 题库也未找到答案，使用默认答案'); _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：答题失败'; handleNoAnswer(quu); } }); } else if (ctResult['code'] == 1 && ctResult['data'] && ctResult['data'] !== '未找到答案') { // 题库找到了答案 _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：题库答案：' + ctResult['data']; applyAnswer(quu, ctResult['data']); } else { _w.top.unrivalWorkInfo = '题目：' + quu['question'].substring(0, 30) + '...：未找到答案'; if (!isAIEnabled) { _w.top.unrivalWorkInfo += '（AI功能未启用）'; } else if (!hasApiKey) { _w.top.unrivalWorkInfo += '（未配置API密钥）'; } handleNoAnswer(quu); } } catch (e) { console.error('答题处理异常:', e); _w.top.unrivalWorkInfo = '题目处理异常：' + e.message; handleNoAnswer(quu); } }; // 添加填空题答案处理函数（参考1.js的实现） function processFillBlankAnswer(quu, answer) { console.log('=== processFillBlankAnswer 开始 ==='); console.log('quu:', JSON.stringify(quu)); console.log('answer:', answer); try { if (!quu || !quu['questionid']) { console.error('填空题参数无效：缺少questionid'); _w.top.unrivalWorkInfo = '填空题参数无效'; return false; } if (!answer || typeof answer !== 'string') { console.error('填空题答案无效：', answer); _w.top.unrivalWorkInfo = '填空题答案无效'; return false; } const trimmedAnswer = answer.trim(); const invalidAnswers = ['**', '未找到答案', '请参考教材', '请根据题目要求', 'void']; if (!trimmedAnswer || trimmedAnswer.length < 1 || invalidAnswers.includes(trimmedAnswer)) { console.log('✗ 填空题答案无效:', trimmedAnswer); console.log('跳过无效答案，使用handleNoAnswer处理'); _w.top.unrivalWorkInfo = '填空题答案无效，已跳过'; return false; } console.log('✓ 填空题答案有效'); const answerTmpArr = answer.split('|'); console.log('解析后的答案数组:', answerTmpArr); const validAnswers = answerTmpArr.filter(a => a && a.trim() && !['void', 'void|void', 'void|void|void', '**', '未找到答案', '请参考教材', '请根据题目要求'].includes(a.trim())); if (validAnswers.length === 0) { console.log('✗ 填空题答案数组中没有有效答案'); console.log('跳过无效答案，使用handleNoAnswer处理'); _w.top.unrivalWorkInfo = '填空题答案无效，已跳过'; return false; } console.log('✓ 填空题答案有效，有效答案数:', validAnswers.length); const questionId = quu['questionid']; console.log('当前题目ID:', questionId); let textareaList = []; console.log('=== 开始查找填空题输入框 ==='); let questionElement = null; const baseId = questionId.replace('answer', ''); console.log('基础ID:', baseId); // 方法1: 通过data属性找到题目容器 questionElement = $(document).find(`.Py-mian1.singleQuesId[data="${baseId}"]`); console.log('方法1 - 通过data属性找到题目元素:', questionElement.length > 0 ? '是' : '否'); if (questionElement.length === 0) { questionElement = $(document).find(`[data="${baseId}"]`); console.log('方法2 - 通过data属性找到题目元素:', questionElement.length > 0 ? '是' : '否'); } if (questionElement.length === 0) { questionElement = $(document).find(`[id-param="${baseId}"]`).closest('.TiMu'); console.log('方法3 - 通过id-param找到题目元素:', questionElement.length > 0 ? '是' : '否'); } if (questionElement.length === 0) { questionElement = $(document).find(`#${questionId}`).closest('.TiMu'); console.log('方法4 - 通过完整ID找到题目元素:', questionElement.length > 0 ? '是' : '否'); } if (questionElement.length === 0) { questionElement = $(document).find(`[id="${baseId}"]`).closest('.TiMu'); console.log('方法5 - 通过基础ID找到题目元素:', questionElement.length > 0 ? '是' : '否'); } if (questionElement.length === 0) { questionElement = $(document).find(`[name*="${baseId}"]`).closest('.TiMu'); console.log('方法6 - 通过name属性找到题目元素:', questionElement.length > 0 ? '是' : '否'); } if (questionElement.length === 0) { const allTiMu = $(document).find('.TiMu'); console.log('方法7 - 遍历所有TiMu元素，总数:', allTiMu.length); allTiMu.each(function() { const $this = $(this); const text = $this.text(); if (text.includes(quu['question'].substring(0, 20))) { questionElement = $this; console.log('通过题目文本匹配找到题目元素'); return false; } }); } if (questionElement.length > 0) { console.log('在题目容器内查找输入框'); // 优先查找特定ID的textarea textareaList = questionElement.find(`textarea[id^="answer${baseId}"]`); console.log('题目容器内找到特定ID的textarea:', textareaList.length); if (textareaList.length === 0) { textareaList = questionElement.find('.editorBlank' + baseId + ' textarea'); console.log('题目容器内找到.editorBlank textarea:', textareaList.length); } if (textareaList.length === 0) { textareaList = questionElement.find('textarea'); console.log('题目容器内找到所有textarea:', textareaList.length); } if (textareaList.length === 0) { textareaList = questionElement.find('input[type="text"]'); console.log('题目容器内找到input[type="text"]:', textareaList.length); } if (textareaList.length === 0) { textareaList = questionElement.find('input'); console.log('题目容器内找到所有input:', textareaList.length); } } // 如果在题目容器内没找到，尝试通过ID直接查找 if (textareaList.length === 0) { console.log('题目容器内未找到输入框，尝试通过ID直接查找'); textareaList = $(document).find(`textarea[id^="answer${baseId}"]`); console.log('通过ID直接查找textarea:', textareaList.length); } if (textareaList.length === 0) { console.log('题目容器内未找到输入框，使用全局查找'); console.log('=== 调试：页面结构分析 ==='); console.log('页面标题:', document.title); console.log('页面URL:', window.location.href); // 查找可能的题目容器 const possibleContainers = ['.question', '.exam-question', '.test-question', '.problem', '.item', '.ques', '.subject', '.q-item', '.exam-item', '.test-item']; possibleContainers.forEach(selector => { const elements = $(document).find(selector); if (elements.length > 0) { console.log(`找到可能的题目容器 ${selector}:`, elements.length); } }); // 查找包含题目文本的元素 const questionText = quu['question'].substring(0, 20); console.log('查找包含文本的元素:', questionText); const allElements = document.querySelectorAll('*'); let matchingElements = []; for (let i = 0; i < allElements.length; i++) { if (allElements[i].textContent && allElements[i].textContent.includes(questionText)) { matchingElements.push({ tag: allElements[i].tagName, id: allElements[i].id, class: allElements[i].className, text: allElements[i].textContent.substring(0, 50) }); } } console.log('包含题目文本的元素:', matchingElements.slice(0, 5)); // 只显示前5个 console.log('=== 调试结束 ==='); textareaList = $(document).find('.Answer .divText .subEditor textarea'); console.log('方法1 - .Answer .divText .subEditor textarea 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('.u-editor-textarea'); console.log('方法2 - .u-editor-textarea 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('textarea[id*="editor"]'); console.log('方法3 - textarea[id*="editor"] 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('.fillblank input'); console.log('方法4 - .fillblank input 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('input[type="text"].fillblank'); console.log('方法5 - input[type="text"].fillblank 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('.topic-fill-blank input'); console.log('方法6 - .topic-fill-blank input 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('input[id*="answer"], input[class*="answer"]'); console.log('方法7 - input[id*="answer"] 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('.TiMu .fillblank input'); console.log('方法8 - .TiMu .fillblank input 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('.fillblank-answer input'); console.log('方法9 - .fillblank-answer input 找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('input[type="text"], input:not([type])'); console.log('方法10 - 所有text输入框找到:', textareaList.length); } if (textareaList.length === 0) { textareaList = $(document).find('textarea'); console.log('方法11 - 所有textarea找到:', textareaList.length); } if (textareaList.length === 0) { // 尝试查找包含题目ID的所有元素 console.log('尝试查找包含题目ID的所有元素'); const elementsWithId = $(document).find(`[id*="${baseId}"]`); console.log('包含题目ID的元素数量:', elementsWithId.length); // 从这些元素中查找textarea和input textareaList = elementsWithId.filter('textarea'); console.log('包含题目ID的textarea:', textareaList.length); if (textareaList.length === 0) { textareaList = elementsWithId.filter('input'); console.log('包含题目ID的input:', textareaList.length); } } if (textareaList.length === 0) { // 尝试查找包含answer的所有元素 console.log('尝试查找包含answer的所有元素'); const elementsWithAnswer = $(document).find('[id*="answer"], [name*="answer"]'); console.log('包含answer的元素数量:', elementsWithAnswer.length); textareaList = elementsWithAnswer.filter('textarea'); console.log('包含answer的textarea:', textareaList.length); if (textareaList.length === 0) { textareaList = elementsWithAnswer.filter('input'); console.log('包含answer的input:', textareaList.length); } } if (textareaList.length === 0) { console.warn('未找到填空题输入框'); console.log('=== 调试：页面上所有输入框 ==='); const allInputs = document.querySelectorAll('input, textarea'); console.log('总输入框数量:', allInputs.length); allInputs.forEach((input, idx) => { console.log(`输入框${idx + 1}:`, { tag: input.tagName, type: input.type, id: input.id, name: input.name, class: input.className, placeholder: input.placeholder }); }); console.log('=== 调试结束 ==='); _w.top.unrivalWorkInfo = '未找到填空题输入框'; return false; } console.log('最终找到输入框数量:', textareaList.length); let filledCount = 0; $.each(textareaList, (i, t) => { if (i < answerTmpArr.length && answerTmpArr[i]) { const _id = $(t).attr('id'); const tagName = $(t).prop('tagName').toLowerCase(); const inputType = $(t).attr('type'); console.log(`第${i+1}个空，元素类型: ${tagName}, ID: ${_id}，答案: ${answerTmpArr[i]}`); try { let filled = false; if (tagName === 'textarea') { // 尝试使用ananas InnerEditor if (typeof editors !== 'undefined' && editors.length > 0) { let editor = null; // 方法1: 通过data-editorindex属性查找 const editorIndex = $(t).closest('[data-editorindex]').attr('data-editorindex'); console.log(`方法1 - 通过data-editorindex找到编辑器索引: ${editorIndex}`); if (editorIndex !== undefined && editors[editorIndex]) { editor = editors[editorIndex]; } // 方法2: 通过ID匹配查找 if (!editor) { const textareaId = _id; console.log(`方法2 - 通过textarea ID匹配查找编辑器: ${textareaId}`); for (let j = 0; j < editors.length; j++) { if (editors[j] && editors[j].renderTo) { const renderToId = editors[j].renderTo; if (renderToId === textareaId || renderToId === `ananas-editor-${textareaId}`) { editor = editors[j]; console.log(`找到匹配的编辑器，索引: ${j}`); break; } } } } // 方法3: 尝试使用第一个编辑器（单选题的情况） if (!editor && editors[0]) { console.log(`方法3 - 使用第一个编辑器`); editor = editors[0]; } if (editor && editor.ueditor && editor.ueditor.isReady) { editor.ueditor.setContent(answerTmpArr[i]); $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（ananas InnerEditor）: ${answerTmpArr[i]}`); filled = true; } else if (editor && editor.ueditor) { console.warn(`ananas InnerEditor未准备好，尝试直接设置textarea值`); $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（直接设置Textarea）: ${answerTmpArr[i]}`); filled = true; } else { console.warn(`未找到可用的ananas InnerEditor实例`); $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（直接设置Textarea）: ${answerTmpArr[i]}`); filled = true; } } else if (_id && typeof UE !== 'undefined' && UE.getEditor) { // 尝试使用标准UEditor const editor = UE.getEditor(_id); if (editor && editor.isReady) { editor.setContent(answerTmpArr[i]); editor.sync(); $(`#${_id}`).val(editor.getContent()); triggerEvents(document.getElementById(_id)); console.log(`✓ 第${i+1}个空填写成功（UEditor）: ${answerTmpArr[i]}`); filled = true; } else { console.warn(`UEditor未准备好，尝试直接设置textarea值`); $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（直接设置Textarea）: ${answerTmpArr[i]}`); filled = true; } } else { // 直接设置textarea值 $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（直接设置Textarea）: ${answerTmpArr[i]}`); filled = true; } } else if (tagName === 'input') { $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（Input）: ${answerTmpArr[i]}`); filled = true; } else { console.warn(`第${i+1}个空未知元素类型: ${tagName}`); } if (filled) filledCount++; } catch (e) { console.error(`填写第${i+1}个空时出错:`, e); console.log(`尝试备用方法填写第${i+1}个空`); try { $(t).val(answerTmpArr[i]); triggerEvents(t); console.log(`✓ 第${i+1}个空填写成功（备用方法）: ${answerTmpArr[i]}`); filledCount++; } catch (e2) { console.error(`备用方法也失败:`, e2); } } } }); console.log('填写成功，共填写', filledCount, '个空'); _w.top.unrivalWorkInfo = `填空题已填写 ${filledCount} 个空`; console.log('=== processFillBlankAnswer 结束（成功） ==='); return true; } catch (error) { console.error('处理填空题时出错：', error); _w.top.unrivalWorkInfo = `填空题处理错误：${error.message}`; console.log('=== processFillBlankAnswer 结束（异常） ==='); return false; } } // 触发事件的辅助函数 function triggerEvents(element) { try { // 触发多种事件，确保系统能检测到输入 const events = ['input', 'change', 'blur', 'keyup', 'keydown', 'focus']; for (let eventType of events) { element.dispatchEvent(new Event(eventType, { bubbles: true })); } console.log('已触发所有事件:', events.join(', ')); } catch (e) { console.error('触发事件时出错：', e); } } // 处理简答题的函数（支持ananas.InnerEditor） function processShortAnswerQuestion(quu, answer) { console.log('=== processShortAnswerQuestion 开始 ==='); console.log('quu:', JSON.stringify(quu)); console.log('answer:', answer); try { if (!quu || !quu['questionid']) { console.error('简答题参数无效：缺少questionid'); _w.top.unrivalWorkInfo = '简答题参数无效'; return false; } if (!answer || typeof answer !== 'string') { console.error('简答题答案无效：', answer); _w.top.unrivalWorkInfo = '简答题答案无效'; return false; } const answerText = answer.trim(); console.log('清理后的答案:', answerText); if (!answerText) { console.error('简答题答案为空'); _w.top.unrivalWorkInfo = '简答题答案为空'; return false; } const invalidAnswers = ['**', '未找到答案', '请参考教材相关章节', '请根据题目要求作答', '请详细说明理由']; if (invalidAnswers.includes(answerText)) { console.log('✗ 简答题答案无效:', answerText); _w.top.unrivalWorkInfo = '简答题答案无效，已跳过'; return false; } console.log('✓ 简答题答案有效'); const questionId = quu['questionid']; const baseId = questionId.replace('answer', ''); console.log('简答题题目ID:', questionId); console.log('基础ID:', baseId); let answerEle = []; // 方法1: 在题目容器内查找 const questionElement = $(document).find(`.Py-mian1.singleQuesId[data="${baseId}"]`); console.log('方法1 - 通过data属性找到题目元素:', questionElement.length > 0 ? '是' : '否'); if (questionElement.length > 0) { answerEle = questionElement.find('.subEditor textarea'); console.log('题目容器内找到.subEditor textarea:', answerEle.length); if (answerEle.length === 0) { answerEle = questionElement.find('textarea'); console.log('题目容器内找到所有textarea:', answerEle.length); } } // 方法2: 通过ID直接查找 if (answerEle.length === 0) { answerEle = $(document).find(`textarea[id^="answer${baseId}"]`); console.log('通过ID直接查找textarea:', answerEle.length); } // 方法3: 查找包含题目ID的所有textarea if (answerEle.length === 0) { const elementsWithId = $(document).find(`[id*="${baseId}"]`); answerEle = elementsWithId.filter('textarea'); console.log('包含题目ID的textarea:', answerEle.length); } // 方法4: 查找.subEditor textarea（原有方法） if (answerEle.length === 0) { answerEle = $(document).find('.subEditor textarea'); console.log('找到.subEditor textarea:', answerEle.length); } // 方法5: 查找所有textarea if (answerEle.length === 0) { answerEle = $(document).find('textarea'); console.log('找到所有textarea:', answerEle.length); } console.log('最终找到的textarea数量:', answerEle.length); if (answerEle && answerEle.length > 0) { $.each(answerEle, (i, t) => { const _id = $(t).attr('id') || $(t).attr('name'); console.log('编辑器ID:', _id); try { // 尝试使用ananas InnerEditor if (typeof editors !== 'undefined' && editors.length > 0) { let editor = null; // 通过ID匹配查找 for (let j = 0; j < editors.length; j++) { if (editors[j] && editors[j].renderTo) { const renderToId = editors[j].renderTo; if (renderToId === _id || renderToId === `ananas-editor-${_id}`) { editor = editors[j]; console.log(`找到匹配的编辑器，索引: ${j}`); break; } } } // 尝试使用第一个编辑器 if (!editor && editors[0]) { editor = editors[0]; console.log(`使用第一个编辑器`); } if (editor && editor.ueditor && editor.ueditor.isReady) { editor.ueditor.setContent(answerText); $(t).val(answerText); triggerEvents(t); console.log('✓ 使用ananas InnerEditor设置内容成功'); } else { console.warn('ananas InnerEditor未准备好，尝试直接设置textarea值'); $(t).val(answerText); triggerEvents(t); console.log('✓ 直接设置textarea值成功'); } } else if (_id && typeof UE !== 'undefined' && UE.getEditor) { // 尝试使用标准UEditor const editor = UE.getEditor(_id); if (editor && editor.isReady) { editor.setContent(answerText); $(t).val(answerText); triggerEvents(t); console.log('✓ 使用UEditor设置内容成功'); } else { console.warn('UEditor未准备好，尝试直接设置textarea值'); $(t).val(answerText); triggerEvents(t); console.log('✓ 直接设置textarea值成功'); } } else { // 直接设置textarea值 $(t).val(answerText); triggerEvents(t); console.log('✓ 直接设置textarea值成功'); } } catch (e) { console.error('设置答案时出错:', e); try { $(t).val(answerText); triggerEvents(t); console.log('✓ 备用方法设置成功'); } catch (e2) { console.error('备用方法也失败:', e2); } } }); _w.top.unrivalWorkInfo = '简答题已填写'; console.log('=== processShortAnswerQuestion 结束（成功） ==='); return true; } console.warn('未找到简答题输入框'); _w.top.unrivalWorkInfo = '未找到简答题输入框'; console.log('=== processShortAnswerQuestion 结束（失败） ==='); return false; } catch (error) { console.error('处理简答题时出错：', error); _w.top.unrivalWorkInfo = `简答题处理错误：${error.message}`; console.log('=== processShortAnswerQuestion 结束（异常） ==='); return false; } } function applyAnswer(quu, answer) { console.log('=== applyAnswer 开始 ==='); console.log('题目类型:', quu['type']); console.log('题目ID:', quu['questionid']); console.log('答案:', answer); console.log('答案类型:', typeof answer); console.log('答案长度:', answer ? answer.length : 0); console.log('答案是否为空:', answer === '' || answer === null || answer === undefined); // 验证答案有效性 if (quu['type'] === '简答题') { const invalidAnswers = ['**', '未找到答案', '请参考教材相关章节', '请根据题目要求作答', '请详细说明理由']; const trimmedAnswer = answer ? answer.trim() : ''; if (!trimmedAnswer || trimmedAnswer.length < 5 || invalidAnswers.includes(trimmedAnswer)) { console.log('✗ 简答题答案无效:', { 原始答案: answer, 清理后答案: trimmedAnswer, 长度: trimmedAnswer.length, 是否在无效列表: invalidAnswers.includes(trimmedAnswer) }); console.log('跳过无效答案，使用handleNoAnswer处理'); handleNoAnswer(quu); return; } console.log('✓ 简答题答案有效'); } let choiceEs = _d.getElementsByTagName('li'); try { switch (quu['type']) { case '判断题': (function() { let answerValue = 'abaabaaba'; if ('正确是对√Tri'.indexOf(answer) >= 0) { answerValue = 'true'; } else if ('错误否错×Fwr'.indexOf(answer) >= 0) { answerValue = 'false'; } for (let u = 0, k = choiceEs.length; u < k; u++) { if (choiceEs[u].getAttribute('val-param') == answerValue && choiceEs[u].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[u].getAttribute('class').includes('cur')) { choiceEs[u].click(); } return; } } // 如果没找到匹配的答案且启用随机作答 if (randomDo == 1 && accuracy < 100) { _w.top.unrivalWorkInfo = quu['question'] + '：未找到正确答案，自动选【错】'; for (let u = 0, k = choiceEs.length; u < k; u++) { if (choiceEs[u].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[u].getAttribute('val-param') == 'false' && choiceEs[u].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[u].getAttribute('class').includes('cur')) { choiceEs[u].click(); } return; } } } })(); break; case '单选题': (function() { let answerData = answer; let found = false; // 直接匹配选项字母 if (/^[A-D]$/.test(answerData)) { for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getElementsByTagName('em')[0].getAttribute('id-param') == answerData && choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } found = true; break; } } } // 如果没有直接匹配字母，尝试匹配选项内容 if (!found && quu['options']) { for (let option in quu['options']) { if (trim(option).replace(/\s/ig, '') == trim(answerData).replace(/\s/ig, '') || trim(option).replace(/\s/ig, '').includes(trim(answerData).replace(/\s/ig, '')) || trim(answerData).replace(/\s/ig, '').includes(trim(option).replace(/\s/ig, ''))) { for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getElementsByTagName('em')[0].getAttribute('id-param') == quu['options'][option]['value'] && choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } found = true; break; } } } if (found) break; } } // 如果没找到匹配的答案且启用随机作答 if (!found && randomDo == 1 && accuracy < 100) { _w.top.unrivalWorkInfo = quu['question'] + '：未找到正确答案，自动选【B】'; for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getElementsByTagName('em')[0].getAttribute('id-param') == 'B' && choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } return; } } } })(); break; case '多选题': (function() { let answerData = trim(answer).replace(/\s/ig, ''); let hasAnswer = false; // 如果是字母组合（如ABC） if (/^[A-D]+$/.test(answerData)) { const answerChars = answerData.split(''); for (let char of answerChars) { for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getElementsByTagName('em')[0].getAttribute('id-param') == char && choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } hasAnswer = true; break; } } } } // 如果没有字母组合，尝试匹配选项内容 if (!hasAnswer && quu['options']) { for (let option in quu['options']) { if (answerData.includes(trim(option).replace(/\s/ig, ''))) { for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getElementsByTagName('em')[0].getAttribute('id-param') == quu['options'][option]['value'] && choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } hasAnswer = true; break; } } } } } // 如果没找到匹配的答案且启用随机作答 if (!hasAnswer && randomDo == 1 && accuracy < 100) { _w.top.unrivalWorkInfo = quu['question'] + '：未找到正确答案，自动全选'; for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } } } } })(); break; case '填空题': (function() { console.log('=== 处理填空题 ==='); console.log('调用 processFillBlankAnswer'); const success = processFillBlankAnswer(quu, answer); console.log('processFillBlankAnswer 返回:', success); if (success) { _w.top.unrivalWorkInfo = '填空题已填写'; } else { _w.top.unrivalWorkInfo = '填空题填写失败'; } console.log('=== 填空题处理结束 ==='); })(); break; case '简答题': // 添加简答题处理 (function() { console.log('=== 处理简答题 ==='); console.log('题目ID:', quu['questionid']); console.log('答案:', answer); const success = processShortAnswerQuestion(quu, answer); console.log('processShortAnswerQuestion 返回:', success); if (success) { _w.top.unrivalWorkInfo = '简答题已填写'; } else { _w.top.unrivalWorkInfo = '简答题填写失败'; } console.log('=== 简答题处理结束 ==='); })(); break; } } catch (e) { console.error('应用答案时出错:', e); } answeredCount++; } function handleNoAnswer(quu) { if (randomDo == 1 && accuracy < 100) { let choiceEs = _d.getElementsByTagName('li'); switch (quu['type']) { case '判断题': _w.top.unrivalWorkInfo = quu['question'] + '：未找到正确答案，自动选【错】'; for (let u = 0, k = choiceEs.length; u < k; u++) { if (choiceEs[u].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[u].getAttribute('val-param') == 'false' && choiceEs[u].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[u].getAttribute('class').includes('cur')) { choiceEs[u].click(); } return; } } break; case '单选题': _w.top.unrivalWorkInfo = quu['question'] + '：未找到正确答案，自动选【B】'; for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getElementsByTagName('em')[0].getAttribute('id-param') == 'B' && choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } return; } } break; case '多选题': _w.top.unrivalWorkInfo = quu['question'] + '：未找到正确答案，自动全选'; for (let y = 0, j = choiceEs.length; y < j; y++) { if (choiceEs[y].getElementsByTagName('em').length < 1) { continue; } if (choiceEs[y].getAttribute('id-param') == quu['questionid'].replace('answer', '')) { if (!choiceEs[y].getAttribute('class').includes('cur')) { choiceEs[y].click(); } } } break; case '填空题': console.log('=== 填空题无有效答案处理 ==='); console.log('题目:', quu['question']); console.log('原因: AI和题库都未找到有效答案'); const textareaList = $(document).find('.Answer .divText .subEditor textarea'); console.log('找到的textarea数量:', textareaList.length); if (textareaList.length > 0) { $.each(textareaList, (i, t) => { const _id = $(t).attr('id'); console.log(`第${i+1}个空，编辑器ID: ${_id}`); setTimeout(() => { try { UE.getEditor(_id).setContent(''); console.log(`✓ 第${i+1}个空已清空`); } catch (e) { console.warn(`清空第${i+1}个空时出错:`, e); } }, 300); }); } _w.top.unrivalWorkInfo = quu['question'] + '：未找到填空题答案，已跳过'; break; case '简答题': console.log('=== 简答题无有效答案处理 ==='); console.log('题目:', quu['question']); console.log('原因: AI和题库都未找到有效答案'); console.log('简答题不使用默认答案，跳过填写'); _w.top.unrivalWorkInfo = quu['question'] + '：未找到有效答案，已跳过'; break; } } } function updateAccuracyDisplay() { const accuracyElement = document.getElementById('currentAccuracy'); if (accuracyElement) { const currentAccuracy = Math.round((answeredCount / totalQuestionNum) * 100); accuracyElement.textContent = `当前正确率: ${currentAccuracy}%`; } } for (let i = 0, l = questionList.length; i < l; i++) { nowTime += parseInt(Math.random() * 3000 + 3500, 10); setTimeout(function () { qu = questionList[i]; let param = 'question=' + encodeURIComponent( qu['question']); if (ctUrl.includes('icodef')) { param += '&type=' + { '单选题': '0', '多选题': '1', '判断题': '3' }[qu['type']] + '&id=' + wid; } GM_xmlhttpRequest({ method: "POST", headers: { 'Content-type': 'application/x-www-form-urlencoded', 'Authorization': token, }, url: ctUrl, timeout: 2000, data: param, onload: async function (res) { await ctOnload(res, qu); }, onerror: function () { ctOnload(false, qu); }, ontimeout: function () { ctOnload(false, qu); } }); }, nowTime); } function trySaveAPI() { // 检查logs对象是否存在 const logFunction = logs && logs.addLog ? logs.addLog.bind(logs) : function(str, color) { console.log(`[日志] ${str}`); }; // 获取作业ID和表单数据 const workId = getQueryVariable('workId'); const classId = getQueryVariable('classId'); const courseId = getQueryVariable('courseId'); if (!workId) { logFunction('❌ 无法获取作业ID，无法保存', 'red'); return; } // 收集所有答案 const formData = new FormData(); const answerInputs = document.querySelectorAll('input[name^="answer"], input[name^="check"]'); answerInputs.forEach(input => { if (input.type === 'radio' || input.type === 'checkbox') { if (input.checked) { formData.append(input.name, input.value); } } else { formData.append(input.name, input.value); } }); // 尝试发送保存请求 const saveUrl = `${location.origin}/work/phone/saveWork?workId=${workId}&classId=${classId}&courseId=${courseId}`; GM_xmlhttpRequest({ method: 'POST', url: saveUrl, data: formData, headers: { 'Content-Type': 'application/x-www-form-urlencoded', }, onload: function(response) { if (response.status === 200) { logFunction('✅ 作业保存成功', 'green'); _w.top.unrivalDoneWorkId = workId; } else { logFunction(`❌ 保存失败，状态码: ${response.status}`, 'red'); } }, onerror: function(error) { logFunction(`❌ 保存请求出错: ${error.message}`, 'red'); } }); } function saveWork() { console.log('尝试保存作业...'); // 检查logs对象是否存在 const logFunction = logs && logs.addLog ? logs.addLog.bind(logs) : function(str, color) { console.log(`[日志] ${str}`); }; // 方法1：尝试调用页面的保存函数 if (typeof _w.save === 'function') { _w.save(); logFunction('使用 save() 函数保存作业', 'green'); } // 方法2：尝试调用 noSubmit else if (typeof _w.noSubmit === 'function') { _w.noSubmit(); logFunction('使用 noSubmit() 函数保存作业', 'green'); } // 方法3：模拟点击保存按钮 else { // 查找保存按钮 const saveButtons = document.querySelectorAll('button, a'); let found = false; for (let btn of saveButtons) { const text = btn.innerText || btn.textContent || ''; const onclick = btn.getAttribute('onclick') || ''; // 匹配保存相关的按钮 if (text.includes('保存') || onclick.includes('save') || onclick.includes('Save')) { btn.click(); logFunction('点击保存按钮成功', 'green'); found = true; break; } } if (!found) { // 尝试查找并点击保存作业的特定按钮 const saveBtn = document.querySelector('#submitFocus, .saveBtn, .save-btn, [onclick*="saveWork"]'); if (saveBtn) { saveBtn.click(); logFunction('找到并点击了保存按钮', 'green'); } else { logFunction('❌ 找不到保存按钮或保存函数', 'red'); // 尝试直接调用超星的保存接口 trySaveAPI(); } } } } // 修改最后的判断逻辑 var workInterval = setInterval(function () { if (busyThread != 0) { return; } clearInterval(workInterval); // 计算实际正确率（已回答的题目数 / 总题目数） const currentAccuracy = Math.round((answeredCount / totalQuestionNum) * 100); // 显示当前正确率 _w.top.unrivalWorkInfo = `已答题数: ${answeredCount}/${totalQuestionNum}, 当前正确率: ${currentAccuracy}%`; if (currentAccuracy >= accuracy && _w.top.unrivalAutoSubmit == '1') { _w.top.unrivalDoneWorkId = getQueryVariable('workId'); _w.top.unrivalWorkInfo = `正确率 ${currentAccuracy}% 符合标准 (${accuracy}%)，已提交答案`; setTimeout(function () { submitCheckTimes(); escapeBlank(); submitAction(); }, parseInt(Math.random() * 2000 + 3000, 10)); } else if (_w.top.unrivalAutoSave == 1) { if (answeredCount > 0) { _w.top.unrivalWorkInfo = `正确率 ${currentAccuracy}% 不符合标准 (${accuracy}%)，已自动保存答案`; setTimeout(function () { _w.top.unrivalDoneWorkId = getQueryVariable('workId'); saveWork(); // 使用新的保存函数 }, 2000); } else { _w.top.unrivalWorkInfo = '没有找到任何答案，不执行保存'; } } else { _w.top.unrivalWorkInfo = '用户设置为不自动保存答案，请手动提交或保存作业'; } }, 1000); } else if (_l.href.indexOf("/exam/test/reVersionTestStartNew") > 0) { console.log('=== 检测到考试模式 ==='); showBox() setTimeout(() => { missonExam() }, 3000) } else if (_l.href.indexOf("/exam/test/reVersionPaperMarkContentNew") > 0) { console.log('=== 检测到考试答案上传页面 ==='); setting.share && (() => { showBox() setTimeout(() => { uploadExam() }, 3000) })() } else if (_l.href.indexOf("/mooc2/exam/exam-list") > 0) { console.log('=== 检测到考试列表页面 ==='); Swal.fire('学习通助手提示', '注意：请谨慎使用脚本考试，开始考试之前请确保该账号已激活脚本。', 'info') } else if (_l.href.includes('work/phone/selectWorkQuestionYiPiYue')) { _w.top.unrivalWorkDone = true; _w.top.unrivalDoneWorkId = getQueryVariable('workId'); } else if (_l.href.includes('stat2-ans.chaoxing.com/task/s/index')) { if (_w.top == _w) { return; } _d.getElementsByClassName('page-container studentStatistic')[0].setAttribute('class', 'studentStatistic'); _d.getElementsByClassName('page-item item-task-list minHeight390')[0].remove(); _d.getElementsByClassName('subNav clearfix')[0].remove(); setInterval(function () { _l.reload(); }, 90000); } else if (_l.href.includes('passport2.') && _l.href.includes('login?refer=http') && autoLogin == 1) { if (!(/^1[3456789]\d{9}$/.test(phoneNumber))) { alert('自动登录的手机号填写错误，无法登陆') return; } if (password == '') { alert('未填写登录密码，无法登陆') return; } GM_xmlhttpRequest({ method: "get", url: 'https://passport2-api.chaoxing.com/v11/loginregister?cx_xxt_passport=json&uname=' + phoneNumber + '&code=' + encodeURIComponent(password), onload: function (res) { try { let ispass = JSON.parse(res.responseText); if (ispass['status']) { _l.href = decodeURIComponent(getQueryVariable('refer')); } else { alert(ispass['mes']); } } catch (err) { console.log(res.responseText); alert('登陆失败'); } }, onerror: function (err) { alert('登陆错误'); } }); } else if (_l.href.includes('unrivalxxtbackground')) { _d.getElementsByTagName("html")[0].innerHTML = ` 学习通挂机小助手

任务列表

暂无运行中的任务

运行日志清空

[00:00:00] 系统初始化完成，等待任务...

`; logs.addLog('此页面不必保持在最前端，后台会自动进行任务', 'green'); setInterval(function () { logs.addLog('此页面不必保持在最前端，后台会自动进行任务', 'green'); logs.addLog('如想禁用后台刷视频功能，请关闭脚本并重启浏览器', 'blue'); }, 120000) GM_addValueChangeListener('unrivalxxtbackgroundinfo', function (name, old_value, new_value, remote) { if (old_value != new_value) { logs.addLog(new_value,'red'); } }); setInterval(function () { if (Math.round(new Date() / 1000) - parseInt(GM_getValue('unrivalBackgroundVideoEnable', '6')) > 15) { logs.addLog('超星挂机小助手可能运行异常，如页面无反应，请尝试重启脚本猫或重启浏览器(脚本猫0.9.0版本有此问题)','red'); } }, 10000); var loopShow = () => { let jobList = GM_getValue('unrivalBackgroundList', '1'); if (jobList == '1') { _d.getElementById('joblist').innerHTML = '请将“超星挂机小助手”升级到最新版并重启浏览器'; } else { try { let jobHtml = ''; for (let i = 0, l = jobList.length; i < l; i++) { let status = ''; if (jobList[i]['done']) { status = '已完成'; } else if (parseInt(jobList[i]['playTime']) > 0) { status = '进行中'; } else { status = '等待中'; } if (jobList[i]['review']) { status += '：复习模式'; } jobHtml += `

` + '[' + status + ']' + jobList[i]['name'] + `

` } _d.getElementById('joblist').innerHTML = jobHtml; } catch (e) { _d.getElementById('joblist').innerHTML = '请将“超星挂机小助手”升级到最新版并重启浏览器！'; } } } loopShow(); setInterval(loopShow, 10000); } // 考试模式函数 function missonExam() { console.log('=== 考试模式开始 ==='); var questionList = [], questionsElement = _d.getElementsByClassName('Py-mian1'), questionNum = questionsElement.length, totalQuestionNum = questionNum; answeredCount = 0; console.log('题目总数:', questionNum); for (let i = 0; i < questionNum; i++) { let questionElement = questionsElement[i], idElements = questionElement.getElementsByTagName('input'), questionId = '0', question = questionElement.getElementsByClassName('Py-m1-title fs16')[0].innerHTML; question = handleImgs(question).replace(/(<([^>]+)>)/ig, '').replace(/[0-9]{1,3}.\[(.*?)\]/ig, '').replaceAll('\n', '').replace(/^\s+/ig, '').replace(/\s+$/ig, ''); console.log('=== 题目解析 ==='); console.log(`第${i+1}个题目`); console.log('题目文本:', question.substring(0, 50)); console.log('题目元素中的input数量:', idElements.length); for (let z = 0, k = idElements.length; z < k; z++) { try { const inputName = idElements[z].getAttribute('name'); const inputId = idElements[z].getAttribute('id'); console.log(`输入框${z}: name="${inputName}", id="${inputId}"`); if (inputName && inputName.indexOf('answer') >= 0) { questionId = inputName.replace('type', ''); console.log('找到answer输入框，questionId =', questionId); break; } } catch (e) { console.error('解析题目时出错:', e); } } if (questionId == '0') { console.warn('未找到questionId，跳过此题'); continue; } questionList.push({ 'question': question, 'type': '填空题', 'questionid': questionId, 'options': { length: 0 } }); } console.log('=== 开始答题 ==='); console.log('题目总数:', questionList.length); let busyThread = questionList.length; let ctOnload = function (res, quu) { busyThread -= 1; var ctResult = { 'code': -1, 'finalUrl': '', 'data': '未找到答案' }; if (res) { try { var responseText = res.responseText; ctResult = JSON.parse(responseText); } catch (e) { console.log(e); if (res.finalUrl.includes('getAnswer.php')) { _w.top.unrivalWorkInfo = '查题错误，服务器连接失败'; return; } } } try { const answer = ctResult['data']; console.log('题库返回答案:', answer); if (!answer || answer == '未找到答案') { console.log('题库未找到答案，跳过'); return; } const success = processFillBlankAnswer(quu, answer); if (success) { _w.top.unrivalWorkInfo = '填空题已填写'; console.log('✓ 填空题填写成功'); } else { _w.top.unrivalWorkInfo = '填空题填写失败'; console.log('✗ 填空题填写失败'); } } catch (e) { console.error('应用答案时出错:', e); } if (busyThread == 0) { console.log('=== 所有题目处理完成 ==='); setTimeout(() => { _w.top.unrivalWorkInfo = '考试答题完成'; }, 1000); } }; for (let i = 0; i < questionList.length; i++) { let quu = questionList[i]; setTimeout(() => { console.log(`=== 处理第${i+1}题 ===`); ctOnload(null, quu); }, i * 3000); } } // 考试答案上传函数 function uploadExam() { console.log('=== 考试答案上传开始 ==='); const examId = getQueryVariable('examId') || getQueryVariable('paperId'); console.log('考试ID:', examId); if (!examId) { console.warn('未找到考试ID'); return; } const answerInputs = document.querySelectorAll('input[name^="answer"], input[name^="check"]'); console.log('找到答案输入框数量:', answerInputs.length); const formData = new FormData(); answerInputs.forEach(input => { if (input.type === 'radio' || input.type === 'checkbox') { if (input.checked) { formData.append(input.name, input.value); } } else { formData.append(input.name, input.value); } }); const uploadUrl = `${location.origin}/exam/test/reVersionPaperMarkContentNew?examId=${examId}`; GM_xmlhttpRequest({ method: 'POST', url: uploadUrl, data: formData, onload: function(response) { if (response.status === 200) { console.log('✅ 考试答案上传成功'); _w.top.unrivalWorkInfo = '考试答案已上传'; } else { console.log('❌ 上传失败，状态码:', response.status); _w.top.unrivalWorkInfo = '考试答案上传失败'; } }, onerror: function(error) { console.error('❌ 上传请求出错:', error); _w.top.unrivalWorkInfo = '考试答案上传出错'; } }); } })();