UESTC离散数学自动答题脚本

package xyz.denvo;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONWriter;
import com.microsoft.playwright.*;
import com.microsoft.playwright.options.LoadState;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.nio.file.Path;
import java.util.Base64;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    private static final Logger log = LoggerFactory.getLogger(Main.class);
    public static void main(String[] args) {
        log.info("正在启动PlayWright...");

        // 有的时候会有个dialog提示新人发帖啥的，关闭按钮的class="d-close"，可以通过点击它关闭这个dialog

        // 答题的URL
        final String[] urls = {"75336320", "75336325", "75336363", "75336409", "75336419", "75336472", "75336504",
            "75336518", "75336560", "75336582", "75336615", "75336673", "75336685", "75336623"};

        // 自动化主要逻辑
        try (Playwright playwright = Playwright.create();
             BrowserContext context = playwright.chromium().launchPersistentContext(
                     Path.of("user_data"),
                     new BrowserType.LaunchPersistentContextOptions().setHeadless(false).setViewportSize(null)
                             .setArgs(List.of("--disable-blink-features=AutomationControlled"))
                             .setUserAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36 Edg/147.0.0.0"))) {
            context.addInitScript(Path.of("stealth.min.js"));
            Page page = context.pages().get(0);
            log.info("已启动浏览器");
            page.navigate("https://www.xuetangx.com/");
            log.info("确定网页登陆后请按下回车继续执行");
            new java.util.Scanner(System.in).nextLine();
            log.info("程序继续执行...");

            //ai(urls, page);
            getAns(urls, page);

        } catch (InterruptedException e) {
            log.error("发生错误！", e);
        }
    }

    private static void getAns(String[] urls, Page page) throws InterruptedException {
        Map<String, Object> jsonMap = new HashMap<>();
        try {
            for (int i = 0; i < urls.length; i++) {
                page.navigate("https://www.xuetangx.com/learn/space/EST07011001151/EST07011001151/29593250/exercise/" + urls[i]);
                log.info("当前正在获取{}的答案", i < 13 ? "第" + (i + 1) + "章" : "期末测试");

                page.waitForLoadState(LoadState.NETWORKIDLE);
                page.waitForSelector("span.curent");
                page.waitForSelector("span.total");
                page.waitForSelector("i.iconfont.right.unselectable");
                int currentIndex = Integer.parseInt(page.locator("span.curent").innerText()),
                        totalIndex = Integer.parseInt(page.locator("span.total").innerText().substring(1));

                // 强制翻到第一题开始获取答案
                for (; currentIndex > 1; currentIndex--) {
                    log.info("当前未翻到第一题！将翻到第一题");
                    page.locator(".tabbar i.iconfont:not(.right)").click();
                    Thread.sleep(1000);
                }

                Map<Integer, String> chapterMap = new HashMap<>();
                for (; currentIndex <= totalIndex; currentIndex++) {
                    log.info("当前正在处理第{}/{}题", currentIndex, totalIndex);
                    Thread.sleep(1000);
                    Locator correctSpans = page.locator("//p[contains(@class, 'myanswer') and contains(text(), '正确答案')]/following-sibling::span");
                    String firstClass = correctSpans.first().getAttribute("class");
                    if (firstClass.contains("panduan")) {
                        // 判断题
                        String answer = firstClass.contains("true") ? "T" : "F";
                        log.info("此题答案：{}", answer);
                        chapterMap.put(currentIndex, answer);
                    } else {
                        // 选择题
                        // 获取容器下所有 .radio_xtb 的文本值
                        // allInnerTexts() 会自动返回一个 List<String>，如 ["A", "B", "D"]
                        List<String> texts = correctSpans.allInnerTexts();
                        StringBuilder sb = new StringBuilder();
                        for (String t : texts) {
                            String cleanText = t.trim();
                            if (!cleanText.isEmpty() && cleanText.matches("[A-Z]")) {
                                sb.append(cleanText);
                            }
                        }
                        String answer = sb.toString();
                        log.info("此题答案：{}", answer);
                        chapterMap.put(currentIndex, answer);
                    }

                    // 翻页处理
                    if (currentIndex != totalIndex) {
                        page.locator("i.iconfont.right.unselectable").click();
                        Thread.sleep(1000);
                    }
                }
                jsonMap.put(urls[i], chapterMap);
            }
        } catch (TimeoutError e) {
            log.error("等待超时", e);
        } finally {
            log.info("处理完成！");
            log.info("最终生成的json如下：{}", JSON.toJSONString(jsonMap, JSONWriter.Feature.PrettyFormatWith4Space));
        }
    }

    private static void ai(String[] urls, Page page) throws InterruptedException {
        // 每次自动答题
        for (int i = 2; i < urls.length; i++) {
            page.navigate("https://www.xuetangx.com/learn/space/EST07011001151/EST07011001151/29593250/exercise/" + urls[i]);
            log.info("当前正在处理{}", i < 13 ? "第" + (i + 1) + "章" : "期末测试");

            // 获取当前题目状态
            page.waitForLoadState(LoadState.NETWORKIDLE);
            page.waitForSelector("span.curent");
            page.waitForSelector("span.total");
            page.waitForSelector("i.iconfont.right.unselectable");
            int currentIndex = Integer.parseInt(page.locator("span.curent").innerText()),
                    totalIndex = Integer.parseInt(page.locator("span.total").innerText().substring(1));
            Locator questionDiv = page.locator(".question");

            // 分每道题处理
            for (; currentIndex <= totalIndex; currentIndex++) {
                log.info("当前处理中 [{}/{}]", currentIndex, totalIndex);

                // 截屏
                byte[] screenshotBytes = questionDiv.screenshot();

                // AI回答
                String screenshotBase64 = Base64.getEncoder().encodeToString(screenshotBytes);
                log.debug("截图base64：{}", screenshotBase64);
                String result = Gemini.getAnswer(screenshotBase64);
                log.info("此题答案：{}", result);
                if (result.length() > 5) {
                    log.error("AI出现错误！");
                    return;
                }

                // 根据AI的答案勾选每一个符合的选项
                if (page.locator(".answerList span.panduan").count() == 2) {
                    log.info("此题为判断题");
                    // 逻辑：A 或类似“正确”含义的点击第一个 span.true
                    // B 或类似“错误”含义的点击第二个不带 true 的 span
                    if (result.contains("A")) {
                        page.locator(".answerList span.panduan.true").click();
                    } else if (result.contains("B")) {
                        page.locator(".answerList span.panduan:not(.true)").click();
                    } else {
                        log.error("检测到判断题，但AI给出的答案无法理解！请人工干预！");
                        new java.util.Scanner(System.in).nextLine();
                    }
                } else {
                    log.info("此题为选择题");
                    for (char choice : result.toCharArray()) {
                        String letter = String.valueOf(choice);
                        page.locator(".answerList span")
                                .filter(new Locator.FilterOptions().setHasText(letter))
                                .first().click();
                        page.waitForTimeout(1000);
                    }
                }

                // 点击提交按钮
                Locator submitBtn = page.locator(".btnCon button.btn:has-text('提交')");
                if (submitBtn.isVisible()) {
                    submitBtn.click();
                    log.info("此题提交成功！");
                    Thread.sleep(1000);
                }

                // 翻页处理
                if (currentIndex != totalIndex) {
                    page.locator("i.iconfont.right.unselectable").click();
                    Thread.sleep(1000);
                }
            }
            Thread.sleep(1000);
            log.info("当前测试已答完");
            Thread.sleep(1000);
        }
        log.info("所有答题已完成！");
    }
}

package xyz.denvo;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Ollama {
    private static final String BASE_URL = "http://localhost:11434/api/chat";
    private static final String MODEL_ID = "qwen3.5:9b";

    private static final Logger log = LoggerFactory.getLogger(Ollama.class);
    private static final HttpClient client = HttpClient.newHttpClient();

    public static String getAnswer(String base64_image) {
        // 构建请求体
        JSONObject requestBody = new JSONObject();
        requestBody.put("model", MODEL_ID);
        requestBody.put("stream", false);
        // 构建 messages
        JSONArray messages = new JSONArray();
        // System
        JSONObject systemMsg = new JSONObject();
        systemMsg.put("role", "system");
        systemMsg.put("content",
                """
                ### Role
                你是一个精密的题目解析与数据提取引擎。
                
                ### Task
                识别图片中的题目类型（单选题、多选题、判断题）并给出标准化的答案选项，以便程序直接解析。
                
                ### Output Format Rules (Strict Enforcement)
                请根据题目类型，严格按下述格式输出，严禁任何解释、前缀或后缀：
                
                1. **单选题 (Single Choice)**: 仅输出一个大写字母。
                   - 示例：A
                2. **多选题 (Multiple Choice)**: 按字母顺序输出所有正确选项，选项间不加任何分隔符。
                   - 示例：ACD
                3. **判断题 (True/False)**: 统一转换为 A 或 B 输出（A 代表正确/对，B 代表错误/错）。
                   - 示例：A
                4. **无法识别**: 若图片无题目或无法辨认，仅输出：NULL
                
                ### Requirements
                - 忽略所有解题过程，只给最终答案。
                - 选项范围：单选 A-D，多选 A-E。
                - 所有的输出必须为大写英文字母。
                - 如果一张图包含多道题，请用逗号分隔（例如：A,ABD,B）。
                """);
        messages.add(systemMsg);
        // User
        JSONObject userMsg = new JSONObject();
        userMsg.put("role", "user");
        userMsg.put("content", "请给出这道题的正确选项（单选题仅输出一个大写字母，多选题输出所有符合的代表选项的大写字母，判断题输出A代表正确，B代表错误）。仅给出答案，不要输出任何其他内容");
        JSONArray images = new JSONArray();
        images.add(base64_image);
        userMsg.put("images", images);
        messages.add(userMsg);

        requestBody.put("messages", messages);

        // 向Ollama发送请求
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody.toJSONString()))
                .build();
        try {
            JSONObject responseJson = JSON.parseObject(client.send(request, HttpResponse.BodyHandlers.ofString()).body());
            return responseJson.getJSONObject("message").getString("content")
                    .replaceAll("[^a-zA-Z]", "").toUpperCase().trim();
        } catch (IOException | InterruptedException e) {
            log.error("出现错误！", e);
            return "";
        }
    }
}

package xyz.denvo;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ProxySelector;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Gemini {
    private static final String MODEL_ID = "gemini-2.5-pro";
    private static final String API_KEY = "xxxxxxxx";
    private static final String BASE_URL = "https://generativelanguage.googleapis.com/v1beta/models/" + MODEL_ID + ":generateContent?key=" + API_KEY;

    private static final Logger log = LoggerFactory.getLogger(Gemini.class);
    private static final HttpClient client = HttpClient.newBuilder()
            //.proxy(ProxySelector.of(new InetSocketAddress("127.0.0.1", 7897)))
            .build();

    public static String getAnswer(String base64_image) {
        // 1. 构建 System Instruction
        JSONObject systemInstruction = new JSONObject();
        JSONArray systemParts = new JSONArray();
        JSONObject systemText = new JSONObject();
        systemText.put("text", """
                ### Role
                你是一个精密的题目解析与数据提取引擎。
                
                ### Task
                识别图片中的题目类型（单选题、多选题、判断题）并给出标准化的答案选项，以便程序直接解析。
                
                ### Output Format Rules (Strict Enforcement)
                请根据题目类型，严格按下述格式输出，严禁任何解释、前缀或后缀：
                
                1. **单选题 (Single Choice)**: 仅输出一个大写字母。
                   - 示例：A
                2. **多选题 (Multiple Choice)**: 按字母顺序输出所有正确选项，选项间不加任何分隔符。
                   - 示例：ACD
                3. **判断题 (True/False)**: 统一转换为 A 或 B 输出（A 代表正确/对，B 代表错误/错）。
                   - 示例：A
                4. **无法识别**: 若图片无题目或无法辨认，仅输出：NULL
                
                ### Requirements
                - 忽略所有解题过程，只给最终答案。
                - 选项范围：单选 A-D，多选 A-E。
                - 所有的输出必须为大写英文字母。
                - 如果一张图包含多道题，请用逗号分隔（例如：A,ABD,B）。
                """);
        systemParts.add(systemText);
        systemInstruction.put("parts", systemParts);

        // 2. 构建 User Content (包含文本和图片)
        JSONObject userContent = new JSONObject();
        userContent.put("role", "user");
        JSONArray userParts = new JSONArray();

        // 文本部分
        JSONObject userText = new JSONObject();
        userText.put("text", "请给出这道题的正确选项（单选题仅输出一个大写字母，多选题输出所有符合的代表选项的大写字母，判断题输出A代表正确，B代表错误）。仅给出答案，不要输出任何其他内容");
        userParts.add(userText);

        // 图片部分 (Gemini 使用 inline_data 结构)
        JSONObject imageData = new JSONObject();
        JSONObject inlineData = new JSONObject();
        inlineData.put("mime_type", "image/png");
        inlineData.put("data", base64_image);
        imageData.put("inline_data", inlineData);
        userParts.add(imageData);

        userContent.put("parts", userParts);

        // 3. 构建完整的 Request Body
        JSONObject requestBody = new JSONObject();
        JSONArray contents = new JSONArray();
        contents.add(userContent);

        requestBody.put("contents", contents);
        requestBody.put("system_instruction", systemInstruction);

        // 4. 配置生成参数 (关闭随机性)
        JSONObject generationConfig = new JSONObject();
        generationConfig.put("temperature", 0.0);
        requestBody.put("generationConfig", generationConfig);

        // 5. 发送 HTTP 请求
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(BASE_URL))
                .header("Content-Type", "application/json")
                //.header("Authorization", "Bearer " + API_KEY)
                .POST(HttpRequest.BodyPublishers.ofString(requestBody.toJSONString()))
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() == 429) {
                log.warn("Gemini API 触发速率限制，请增加脚本延时！");
                return "";
            }

            JSONObject responseJson = JSON.parseObject(response.body());

            log.debug("Gemini返回：{}", responseJson.toJSONString());

            // Gemini 的响应路径: candidates[0].content.parts[0].text
            String content = responseJson.getJSONArray("candidates")
                    .getJSONObject(0)
                    .getJSONObject("content")
                    .getJSONArray("parts")
                    .getJSONObject(0)
                    .getString("text");

            // 清理并格式化输出
            return content.replaceAll("[^a-zA-Z]", "").toUpperCase().trim();

        } catch (IOException | InterruptedException | NullPointerException e) {
            log.error("出现错误！", e);
            return "";
        }
    }
}