Merge pull request #551 from XingHeYuZhuan/pending

resources/IMNC/adapters.yaml

@@ -5,11 +5,11 @@ adapters:
     asset_js_path: "imnc_01.js"
     import_url: "https://webvpn.imnc.edu.cn"
     maintainer: "浮笙-WindDrift"
-    description: "无需校园网，使用 WebVPN 登录，登录后依次点击【教务管理系统】-【本学期课表】-【个人课表】，在【小节课表】页面（即第1节、第2节...）点击下方【执行导入】。"
+    description: "无需校园网，使用 WebVPN 登录，登录后依次点击【教务管理系统】-【本学期课表】，在“本学期课程安排”页面点击【执行导入】。"
   - adapter_id: "IMNC_02"
     adapter_name: "已连接校园网？"
     category: "BACHELOR_AND_ASSOCIATE"
     asset_js_path: "imnc_01.js"
     import_url: "http://211.82.176.48/academic/login/imnc/loginIds6.jsp"
     maintainer: "浮笙-WindDrift"
-    description: "需要校园网，适用于上方无法登录的情况，导入方法与上方相同。"
+    description: "需要校园网，适用于上方无法登录的情况，登录后依次点击【教务管理系统】-【本学期课表】，在“本学期课程安排”页面点击【执行导入】。"

resources/IMNC/imnc_01.js

@@ -1,6 +1,9 @@
 /**
  * 呼和浩特民族学院 (IMNC) 课表解析脚本-通过 WebVPN 登录
- * 放置于测试目录用于真机测试
+ * 目标页面：教务系统【本学期课表】（"本学期课程安排"页面）
+ * 从课程主表读取课程号、课程序号、学分、选课属性，写入课程备注 remark
+ * 桥接 API 使用 v2：window.shiguangBridge(同步) / window.shiguangBridgePromise(异步)
+ * 导入时一并写入默认时间表（10 节）与默认学期总周数（16 周）
  */
 
 // 清理 <wbr> 标签
@@ -8,14 +11,31 @@ function cleanWbr(str) {
     return str ? str.replace(/<wbr\s*\/?>/gi, '') : str;
 }
 
+// 默认时间表（TimeSlotJsonModel：number 从 1 递增，HH:mm 格式）
+const TIME_SLOTS = [
+    { number: 1, startTime: "08:30", endTime: "09:15" },
+    { number: 2, startTime: "09:25", endTime: "10:10" },
+    { number: 3, startTime: "10:30", endTime: "11:15" },
+    { number: 4, startTime: "11:25", endTime: "12:10" },
+    { number: 5, startTime: "14:30", endTime: "15:15" },
+    { number: 6, startTime: "15:25", endTime: "16:10" },
+    { number: 7, startTime: "16:30", endTime: "17:15" },
+    { number: 8, startTime: "17:25", endTime: "18:10" },
+    { number: 9, startTime: "19:30", endTime: "20:15" },
+    { number: 10, startTime: "20:25", endTime: "21:10" }
+];
+
+// 默认本学期总周数（CourseConfigJsonModel.semesterTotalWeeks，未传入的字段使用应用默认值）
+const SEMESTER_TOTAL_WEEKS = 16;
+
 // 周次解析函数
 function parseWeeks(weekStr) {
     let weeks = [];
     if (!weekStr) return weeks;
     let isSingle = weekStr.includes('单');
     let isDouble = weekStr.includes('双');
-    
-    // 匹配 "1-16", "第1-9周"
+
+    // 匹配 "1-16", "第1-9周", "全周（1-16）"
     let match = weekStr.match(/(\d+)-(\d+)/);
     if (match) {
         let start = parseInt(match[1]);
@@ -35,121 +55,255 @@ function parseWeeks(weekStr) {
     return weeks;
 }
 
-// 核心解析函数
-function fetchAndParseCourses() {
-    let courses = [];
-    let table = document.querySelector('#timetable');
-    if (!table) return null;
-    
-    let rows = table.querySelectorAll('tr');
-    // 第 0 行是表头，从第 1 行开始遍历节次
-    for (let i = 1; i < rows.length; i++) {
-        let row = rows[i];
-        let cells = row.querySelectorAll('td');
-        let section = i; // 1 到 13 节
-        
-        for (let j = 0; j < cells.length; j++) {
-            let cell = cells[j];
-            let day = j + 1; // 星期 1 到 7
-            
-            let html = cell.innerHTML.trim();
-            if (!html || html === '&nbsp;') continue;
-            
-            // 按 <br> 分割
-            let parts = html.split(/<br\s*\/?>/i).map(s => s.trim()).filter(s => s !== '');
-            
-            // 每 5 个元素代表一个完整的课程块
-            for (let k = 0; k < parts.length; k += 5) {
-                if (k + 3 >= parts.length) break; 
-                
-                let namePart = parts[k]; 
-                let position = parts[k+1];
-                let teacher = parts[k+2];
-                let weekStr = parts[k+3];
-                // parts[k+4] 是 "讲授" 等类型，暂时不需要存入
-                
-                // 提取书名号内的课程名
-                let nameMatch = namePart.match(/&lt;&lt;(.*?)&gt;&gt;/);
-                let name = nameMatch ? nameMatch[1] : namePart;
-                // 兼容某些浏览器可能将转义符还原的情况
-                if (!nameMatch) {
-                    let nameMatch2 = namePart.match(/<<(.*?)>>/);
-                    if (nameMatch2) name = nameMatch2[1];
-                }
-                
-                // 清理 <wbr> 标签
-                name = cleanWbr(name);
-                position = cleanWbr(position);
-                teacher = cleanWbr(teacher);
-                
-                let weeks = parseWeeks(weekStr);
-                
-                // 查找同一天、同名、同老师、同地点、同周次，且正好是上一节的课程（合并连上的课）
-                let existingCourse = courses.find(c => 
-                    c.name === name && 
-                    c.day === day && 
-                    c.teacher === teacher && 
-                    c.position === position &&
-                    JSON.stringify(c.weeks) === JSON.stringify(weeks) &&
-                    c.endSection === section - 1 
-                );
-                
-                if (existingCourse) {
-                    existingCourse.endSection = section;
-                } else {
-                    courses.push({
-                        name: name,
-                        teacher: teacher,
-                        position: position,
-                        day: day,
-                        startSection: section,
-                        endSection: section,
-                        weeks: weeks
-                    });
-                }
-            }
-        }
+// 星期映射（星期一~星期日 -> 1~7）
+const DAY_NAME_MAP = {
+    '星期一': 1, '星期二': 2, '星期三': 3, '星期四': 4,
+    '星期五': 5, '星期六': 6, '星期日': 7, '星期天': 7
+};
+
+function parseDay(dayStr) {
+    if (!dayStr) return 0;
+    let normalized = dayStr.replace(/\s+/g, '');
+    if (DAY_NAME_MAP[normalized]) return DAY_NAME_MAP[normalized];
+    let match = normalized.match(/星期([一二三四五六日天])/);
+    if (!match) match = normalized.match(/周([一二三四五六日天])/);
+    if (match) {
+        let index = '一二三四五六日天'.indexOf(match[1]);
+        return index >= 0 ? index + 1 : 0;
     }
-    return courses;
+    return 0;
+}
+
+// 节次解析："第1-2节" -> {start:1, end:2}；"第3节" -> {start:3, end:3}
+function parseSections(sectionStr) {
+    if (!sectionStr) return null;
+    let rangeMatch = sectionStr.match(/第\s*(\d+)\s*[-—~至]\s*(\d+)\s*节/);
+    if (rangeMatch) {
+        return { start: parseInt(rangeMatch[1]), end: parseInt(rangeMatch[2]) };
+    }
+    let singleMatch = sectionStr.match(/第\s*(\d+)\s*节/);
+    if (singleMatch) {
+        let section = parseInt(singleMatch[1]);
+        return { start: section, end: section };
+    }
+    return null;
 }
 
 function cleanCellText(cell) {
     return cell.textContent.replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
 }
 
-function parseNoArrangementCourses() {
-    let table = document.querySelector('#noArrangement');
-    if (!table) return [];
+// 教师单元格解析：任课教师以链接列表展示，用"、"拼接
+function parseTeacherCell(cell) {
+    let links = cell.querySelectorAll('a');
+    if (links.length > 0) {
+        let names = [];
+        for (let i = 0; i < links.length; i++) {
+            let name = cleanWbr(links[i].textContent).replace(/\s+/g, ' ').trim();
+            if (name) names.push(name);
+        }
+        if (names.length > 0) return names.join('、');
+    }
+    return cleanCellText(cell);
+}
+
+// 解析"上课时间、地点"单元格内的嵌套表格，每行：周次 / 星期 / 节次 / 地点
+function parseScheduleCell(cell) {
+    let slots = [];
+    let rows = cell.querySelectorAll('table tr');
+    for (let i = 0; i < rows.length; i++) {
+        let tds = rows[i].querySelectorAll('td');
+        if (tds.length < 3) continue;
+
+        let weekStr = cleanCellText(tds[0]);
+        let dayStr = cleanCellText(tds[1]);
+        let sectionStr = cleanCellText(tds[2]);
+        let position = tds.length > 3 ? cleanCellText(tds[3]) : '';
+
+        // 无星期或节次的子行（仅有周次的课程安排）跳过
+        let day = parseDay(dayStr);
+        let section = parseSections(sectionStr);
+        if (!day || !section) continue;
+
+        slots.push({
+            weeks: parseWeeks(weekStr),
+            weeksText: weekStr,
+            day: day,
+            startSection: section.start,
+            endSection: section.end,
+            position: cleanWbr(position)
+        });
+    }
+    return slots;
+}
+
+// 在单个文档中定位课程主表：table.infolist_tab 且表头含"课程号"（排除"上课大节"对照表）
+function findCourseTableInDoc(doc) {
+    let tables = doc.querySelectorAll('table.infolist_tab');
+    for (let i = 0; i < tables.length; i++) {
+        let headerCells = tables[i].rows[0] ? tables[i].rows[0].cells : [];
+        for (let j = 0; j < headerCells.length; j++) {
+            if (cleanCellText(headerCells[j]).replace(/\s+/g, '') === '课程号') {
+                return tables[i];
+            }
+        }
+    }
+    return null;
+}
+
+// 收集文档内所有可访问的同源框架文档（教务系统为 frameset 结构，课表位于 mainFrame 内）
+function collectFrameDocs(doc, docs, depth) {
+    if (depth > 3) return;
+    let frames = doc.querySelectorAll('frame, iframe');
+    for (let i = 0; i < frames.length; i++) {
+        try {
+            let frameDoc = frames[i].contentDocument ||
+                (frames[i].contentWindow ? frames[i].contentWindow.document : null);
+            if (frameDoc && docs.indexOf(frameDoc) < 0) {
+                docs.push(frameDoc);
+                collectFrameDocs(frameDoc, docs, depth + 1);
+            }
+        } catch (e) { /* 跨域框架无法访问，忽略 */ }
+    }
+    return docs;
+}
+
+function findCourseTable() {
+    // 优先在当前文档查找
+    let table = findCourseTableInDoc(document);
+    if (table) return table;
+    // 当前文档没有（如处于 index_frame 顶层框架），遍历同源框架查找
+    let frameDocs = collectFrameDocs(document, [], 0);
+    for (let i = 0; i < frameDocs.length; i++) {
+        let tableInFrame = findCourseTableInDoc(frameDocs[i]);
+        if (tableInFrame) return tableInFrame;
+    }
+    return null;
+}
+
+// 组装课程备注（官方 ImportCourseJsonModel 字段 remark，字符数限制 300）
+function buildRemark(courseId, sequence, credit, electiveAttr) {
+    let lines = [];
+    if (courseId) lines.push('课程号：' + courseId);
+    if (sequence) lines.push('课程序号：' + sequence);
+    if (credit) lines.push('学分：' + credit);
+    if (electiveAttr) lines.push('选课属性：' + electiveAttr);
+    let remark = lines.join('\n');
+    if (remark.length > 300) remark = remark.substring(0, 300);
+    return remark;
+}
+
+// 核心解析函数：在"本学期课程安排"页面按表头定位列并逐行解析
+function fetchCurrentSemesterCourses() {
+    let table = findCourseTable();
+    if (!table) return null;
+
+    // 按表头文本建立列索引（表头文本去除空白，兼容"课程<br>序号"、"学 分"等换行写法）
+    let indexMap = {};
+    let headerCells = table.rows[0] ? table.rows[0].cells : [];
+    for (let i = 0; i < headerCells.length; i++) {
+        indexMap[cleanCellText(headerCells[i]).replace(/\s+/g, '')] = i;
+    }
+
+    function columnIndex(keys) {
+        for (let i = 0; i < keys.length; i++) {
+            if (indexMap[keys[i]] !== undefined) return indexMap[keys[i]];
+        }
+        return -1;
+    }
+
+    let courseIdIdx = columnIndex(['课程号']);
+    let sequenceIdx = columnIndex(['课程序号']);
+    let nameIdx = columnIndex(['课程名称']);
+    let teacherIdx = columnIndex(['任课教师']);
+    let creditIdx = columnIndex(['学分']);
+    let electiveAttrIdx = columnIndex(['选课属性']);
+    let scheduleIdx = columnIndex(['上课时间、地点', '上课时间地点']);
+
+    if (nameIdx < 0 || scheduleIdx < 0) return null;
 
-    let rows = table.querySelectorAll('tr');
     let courses = [];
-    let seen = {};
-
-    for (let i = 1; i < rows.length; i++) {
-        let cells = rows[i].querySelectorAll('td');
-        if (cells.length < 8) continue;
-
-        let course = {
-            courseId: cleanCellText(cells[0]),
-            name: cleanCellText(cells[1]),
-            sequence: cleanCellText(cells[2]),
-            teacher: cleanCellText(cells[3]) || '未填写教师',
-            combinedClass: cleanCellText(cells[4]),
-            weeks: cleanCellText(cells[5]),
-            day: cleanCellText(cells[6]),
-            position: cleanCellText(cells[7])
-        };
-
-        if (!course.courseId && !course.name) continue;
-
-        let key = [course.courseId, course.name, course.sequence, course.teacher, course.combinedClass, course.weeks, course.day, course.position].join('|');
-        if (seen[key]) continue;
-
-        seen[key] = true;
-        courses.push(course);
+    let skipped = [];
+
+    // 第 0 行是表头，从第 1 行开始遍历课程
+    for (let i = 1; i < table.rows.length; i++) {
+        let cells = table.rows[i].cells;
+        function cellAt(index) {
+            return index >= 0 && index < cells.length ? cells[index] : null;
+        }
+
+        let nameCell = cellAt(nameIdx);
+        let name = nameCell ? cleanWbr(cleanCellText(nameCell)) : '';
+        if (!name) continue;
+
+        let courseIdCell = cellAt(courseIdIdx);
+        let sequenceCell = cellAt(sequenceIdx);
+        let creditCell = cellAt(creditIdx);
+        let electiveAttrCell = cellAt(electiveAttrIdx);
+        let teacherCell = cellAt(teacherIdx);
+
+        let courseId = courseIdCell ? cleanCellText(courseIdCell) : '';
+        let sequence = sequenceCell ? cleanCellText(sequenceCell) : '';
+        let credit = creditCell ? cleanCellText(creditCell) : '';
+        let electiveAttr = electiveAttrCell ? cleanCellText(electiveAttrCell) : '';
+        let teacher = teacherCell ? parseTeacherCell(teacherCell) : '';
+
+        let remark = buildRemark(courseId, sequence, credit, electiveAttr);
+
+        let scheduleCell = cellAt(scheduleIdx);
+        let slots = scheduleCell ? parseScheduleCell(scheduleCell) : [];
+
+        if (slots.length === 0) {
+            // 无任何有效排课位的课程（如仅有周次的"形势与政策（三）"、无时间安排的"体能测试Ⅱ"）
+            let weeksText = '未填写周次';
+            if (scheduleCell) {
+                let firstTd = scheduleCell.querySelector('table td');
+                if (firstTd) {
+                    let text = cleanCellText(firstTd);
+                    if (text) weeksText = text;
+                }
+            }
+            skipped.push({
+                name: name,
+                teacher: teacher || '未填写教师',
+                weeks: weeksText
+            });
+            continue;
+        }
+
+        for (let k = 0; k < slots.length; k++) {
+            let slot = slots[k];
+            let courseBlock = {
+                name: name,
+                teacher: teacher,
+                position: slot.position,
+                day: slot.day,
+                startSection: slot.startSection,
+                endSection: slot.endSection,
+                weeks: slot.weeks,
+                remark: remark
+            };
+
+            // 查找同一天、同名、同老师、同地点、同周次、同备注，且正好是上一节的课程（合并连上的课）
+            let existingCourse = courses.find(c =>
+                c.name === courseBlock.name &&
+                c.day === courseBlock.day &&
+                c.teacher === courseBlock.teacher &&
+                c.position === courseBlock.position &&
+                JSON.stringify(c.weeks) === JSON.stringify(courseBlock.weeks) &&
+                c.remark === courseBlock.remark &&
+                c.endSection === courseBlock.startSection - 1
+            );
+
+            if (existingCourse) {
+                existingCourse.endSection = courseBlock.endSection;
+            } else {
+                courses.push(courseBlock);
+            }
+        }
     }
 
-    return courses;
+    return { courses: courses, skipped: skipped };
 }
 
 function formatNoArrangementMessage(courses) {
@@ -162,42 +316,74 @@ function formatNoArrangementMessage(courses) {
     return `检测到 ${courses.length} 门课程没有具体上课时间或地点，无法自动放入课表：\n\n${lines.join('\n')}\n\n请在确认课程时间后重新导入，点击【继续】将导入已知课程。`;
 }
 
+// 保存课表配置（默认学期总周数；失败不阻断课程导入）
+async function saveCourseConfigData() {
+    try {
+        await window.shiguangBridgePromise.saveCourseConfig(JSON.stringify({
+            semesterTotalWeeks: SEMESTER_TOTAL_WEEKS
+        }));
+        window.shiguangBridge.showToast(`已设置默认学期总周数：${SEMESTER_TOTAL_WEEKS} 周`);
+        return true;
+    } catch (error) {
+        window.shiguangBridge.showToast("保存课表配置失败: " + error.message);
+        return false;
+    }
+}
+
+// 导入预设时间段（默认时间表；失败不阻断课程导入）
+async function importPresetTimeSlots() {
+    try {
+        await window.shiguangBridgePromise.savePresetTimeSlots(JSON.stringify(TIME_SLOTS));
+        window.shiguangBridge.showToast(`预设时间段导入成功（${TIME_SLOTS.length} 节）！`);
+        return true;
+    } catch (error) {
+        window.shiguangBridge.showToast("导入时间段失败: " + error.message);
+        return false;
+    }
+}
+
 // 调度流程
 async function runImportFlow() {
     try {
         window.shiguangBridge.showToast("开始解析课表...");
-        
+
         const alertConfirmed = await window.shiguangBridgePromise.showAlert(
             "导入确认",
-            "请确保您目前处于教务系统的“学生课表”显示页面。\n是否立即提取并导入课表？",
+            "请确保您目前处于教务系统的“本学期课表”显示页面（页面标题为“本学期课程安排”）。\n是否立即提取并导入课表？",
             "开始提取"
         );
-        
+
         if (!alertConfirmed) {
             window.shiguangBridge.showToast("导入已取消");
             return;
         }
-        
-        let courses = fetchAndParseCourses();
-        
-        if (!courses || courses.length === 0) {
-            await window.shiguangBridgePromise.showAlert("错误", "未在当前页面找到课表数据，请确认是否处于课表页面，或联系适配开发者。", "好的");
+
+        const result = fetchCurrentSemesterCourses();
+
+        if (!result || result.courses.length === 0) {
+            await window.shiguangBridgePromise.showAlert("错误", "未在当前页面找到可导入的课程数据，请确认是否处于“本学期课表”页面，或联系适配开发者。", "好的");
             return;
         }
 
-        let noArrangementCourses = parseNoArrangementCourses();
-        if (noArrangementCourses.length > 0) {
+        if (result.skipped.length > 0) {
             await window.shiguangBridgePromise.showAlert(
                 "存在未安排课程",
-                formatNoArrangementMessage(noArrangementCourses),
+                formatNoArrangementMessage(result.skipped),
                 "继续"
             );
         }
-        
-        await window.shiguangBridgePromise.saveImportedCourses(JSON.stringify(courses));
-        window.shiguangBridge.showToast(`成功导入 ${courses.length} 门课程块！`);
+
+        // 课表配置（学期总周数），失败不阻断
+        await saveCourseConfigData();
+
+        await window.shiguangBridgePromise.saveImportedCourses(JSON.stringify(result.courses));
+        window.shiguangBridge.showToast(`成功导入 ${result.courses.length} 门课程块！`);
+
+        // 默认时间表，失败不阻断
+        await importPresetTimeSlots();
+
         window.shiguangBridge.notifyTaskCompletion();
-        
+
     } catch (error) {
         window.shiguangBridge.showToast("导入发生错误: " + error.message);
     }

resources/SWU/adapters.yaml

@@ -6,4 +6,4 @@ adapters:
     asset_js_path: "swu.js"
     import_url: "https://i.swu.edu.cn/"
     maintainer: "小漫君"
-    description: "登录西南大学信息门户后进入教务系统课表页面，再执行导入脚本；脚本会自动套用西南大学节次时间。"
+    description: "基于正方新一代教务接口取数。请从办事大厅(i.swu.edu.cn)登录后进入教务系统课表查询页面，再执行导入脚本；脚本会自动套用西南大学节次时间。"

resources/SWU/swu.js

@@ -1,170 +1,510 @@
-// 西南大学教务适配脚本（维护者：小漫君）
-// 适配说明：登录 i.swu.edu.cn 后进入教务系统课表页面执行导入；
-// 脚本会自动套用西南大学的节次时间。
-
-(() => {
-  const DEFAULT_TIME_SLOTS = [
-    { number: 1, startTime: '08:00', endTime: '08:45' },
-    { number: 2, startTime: '08:55', endTime: '09:40' },
-    { number: 3, startTime: '10:00', endTime: '10:45' },
-    { number: 4, startTime: '10:55', endTime: '11:40' },
-    { number: 5, startTime: '12:10', endTime: '12:55' },
-    { number: 6, startTime: '13:05', endTime: '13:50' },
-    { number: 7, startTime: '14:00', endTime: '14:45' },
-    { number: 8, startTime: '14:55', endTime: '15:40' },
-    { number: 9, startTime: '15:50', endTime: '16:35' },
-    { number: 10, startTime: '16:55', endTime: '17:40' },
-    { number: 11, startTime: '17:50', endTime: '18:35' },
-    { number: 12, startTime: '19:20', endTime: '20:05' },
-    { number: 13, startTime: '20:15', endTime: '21:00' },
-    { number: 14, startTime: '21:10', endTime: '21:55' },
-  ];
-
-  const toast = (message) => {
-    if (window.shiguangBridge?.showToast) {
-      window.shiguangBridge.showToast(message);
-    } else {
-      console.log(message);
-    }
-  };
-
-  const normalize = (value) => String(value || '').replace(/\s+/g, ' ').trim();
-
-  const parseWeeks = (text) => {
-    const source = normalize(text);
-    const weeks = new Set();
-    const rangePattern = /(\d{1,2})\s*[-~至]\s*(\d{1,2})\s*周?/g;
-    let rangeMatch;
-    while ((rangeMatch = rangePattern.exec(source)) !== null) {
-      const start = Number(rangeMatch[1]);
-      const end = Number(rangeMatch[2]);
-      for (let week = Math.min(start, end); week <= Math.max(start, end); week += 1) {
-        weeks.add(week);
-      }
-    }
-    const singlePattern = /第?\s*(\d{1,2})\s*周/g;
-    let singleMatch;
-    while ((singleMatch = singlePattern.exec(source)) !== null) {
-      weeks.add(Number(singleMatch[1]));
-    }
-    return [...weeks].filter((week) => week > 0).sort((a, b) => a - b);
-  };
-
-  const parseDay = (text) => {
-    const source = normalize(text);
-    const names = ['一', '二', '三', '四', '五', '六', '日'];
-    for (let i = 0; i < names.length; i += 1) {
-      if (source.includes(`星期${names[i]}`) || source.includes(`周${names[i]}`)) return i + 1;
-    }
-    const digit = source.match(/(?:星期|周)\s*([1-7])/);
-    return digit ? Number(digit[1]) : 0;
-  };
-
-  const parseSections = (text) => {
-    const source = normalize(text);
-    const range = source.match(/第?\s*(\d{1,2})\s*[-~至]\s*(\d{1,2})\s*节/);
-    if (range) return [Number(range[1]), Number(range[2])];
-    const single = source.match(/第?\s*(\d{1,2})\s*节/);
-    if (single) return [Number(single[1]), Number(single[1])];
-    return [0, 0];
-  };
-
-  const collectCandidateText = () => {
-    const selectors = [
-      '[class*="course"]',
-      '[class*="kb"]',
-      '[class*="timetable"]',
-      '[class*="schedule"]',
-      'td',
-      '.el-table__row',
-      'tr',
-    ];
-    const elements = new Set();
-    selectors.forEach((selector) => document.querySelectorAll(selector).forEach((element) => elements.add(element)));
-    return [...elements].map((element) => normalize(element.innerText || element.textContent)).filter((text) => text.length >= 8);
-  };
-
-  const parseCoursesFromDom = () => {
-    const rows = collectCandidateText();
-    const courses = [];
-    rows.forEach((text) => {
-      const day = parseDay(text);
-      const [startSection, endSection] = parseSections(text);
-      if (!day || !startSection) return;
-      const parts = text.split(/[\n;；,，]/).map(normalize).filter(Boolean);
-      const name = parts.find((part) => !/(星期|周[一二三四五六日1-7]|节|校区|教室|教师|老师|周)/.test(part)) || parts[0] || '未命名课程';
-      const room = parts.find((part) => /(楼|室|教室|校区|实验|馆)/.test(part)) || '';
-      const teacher = parts.find((part) => /(老师|教师|讲师|教授)/.test(part))?.replace(/(老师|教师)[:：]?/, '') || '';
-      courses.push({
-        name,
-        teacher,
-        position: room,
-        day,
-        startSection,
-        endSection,
-        weeks: parseWeeks(text),
-      });
-    });
-    const seen = new Set();
-    return courses.filter((course) => {
-      const key = `${course.name}-${course.day}-${course.startSection}-${course.endSection}-${course.position}`;
-      if (seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  };
-
-  const readJsonFromPage = () => {
-    const scripts = [...document.scripts].map((script) => script.textContent || '').join('\n');
-    const matches = scripts.match(/\[[\s\S]{0,200000}?(?:course|kcmc|课程|teacher|jxcd|教室)[\s\S]{0,200000}?\]/gi) || [];
-    for (const candidate of matches) {
-      try {
-        const parsed = JSON.parse(candidate);
-        if (Array.isArray(parsed) && parsed.length) return parsed;
-      } catch (_) {
-      }
-    }
-    return [];
-  };
-
-  const parseCoursesFromJson = () => readJsonFromPage().map((item) => {
-    const text = JSON.stringify(item);
-    const day = Number(item.day || item.weekday || item.xq || item.xqj || parseDay(text));
-    const start = Number(item.startSection || item.start || item.jc || item.ksjc || parseSections(text)[0]);
-    const end = Number(item.endSection || item.end || item.jsjc || parseSections(text)[1] || start);
+// 西南大学(swu.edu.cn) 拾光课程表适配脚本
+// 基于正方新一代教务系统接口适配
+// 维护者：小漫君(xiaomanjun233)
+// 出现问题请提issues或者提交pr更改,这更加快速
+//
+// 通过正方接口 xskbcx_cxXsgrkb 拉取个人课表 JSON（kbList），解析课程名、教师、教室、
+// 星期、节次和周次（含单双周）。集中实践课（军训、毕业设计等）无星期节次，直接忽略不导入。
+// 交互上自动读取教务系统的学年/学期下拉列表，用户只需依次点选即可，无需手动输入。
+// 通过 xskbcx_cxXskbcxIndex 读取学年学期选项、xskbcxZccx_cxZcByXnxq 取所选学期开学日期；
+// 导入课程、课表配置与西南大学 14 节节次时间。
+//
+// 使用方式：从办事大厅(i.swu.edu.cn)登录后进入教务系统(jw.swu.edu.cn/jwglxt)课表查询页面，再执行导入。
+
+/**
+ * 解析周次字符串，处理单双周和周次范围。
+ */
+function parseWeeks(weekStr) {
+    if (!weekStr) return [];
+
+    const weekSets = weekStr.split(',');
+    let weeks = [];
+
+    for (const set of weekSets) {
+        const trimmedSet = set.trim();
+
+        const rangeMatch = trimmedSet.match(/(\d+)-(\d+)周/);
+        const singleMatch = trimmedSet.match(/^(\d+)周/); // 匹配以数字周结束的
+
+        let start = 0;
+        let end = 0;
+        let processed = false;
+
+        if (rangeMatch) { // 范围, 如 "1-5周"
+            start = Number(rangeMatch[1]);
+            end = Number(rangeMatch[2]);
+            processed = true;
+        } else if (singleMatch) { // 单个周, 如 "6周"
+            start = end = Number(singleMatch[1]);
+            processed = true;
+        }
+
+        if (processed) {
+            // 确定单双周
+            const isSingle = trimmedSet.includes('(单)');
+            const isDouble = trimmedSet.includes('(双)');
+
+            for (let w = start; w <= end; w++) {
+                if (isSingle && w % 2 === 0) continue; // 单周跳过偶数
+                if (isDouble && w % 2 !== 0) continue; // 双周跳过奇数
+                weeks.push(w);
+            }
+        }
+    }
+
+    // 去重并排序
+    return [...new Set(weeks)].sort((a, b) => a - b);
+}
+
+/**
+ * 拼接教务系统接口地址。
+ * 西南大学教务（jw.swu.edu.cn）的正方新一代部署在 /jwglxt 子路径下，
+ * 接口路径必须带上该前缀；校外经 WebVPN 访问时路径还带有 /http/<hex> 前缀，需保留。
+ */
+function buildApiUrl(path) {
+    const prefixMatch = window.location.pathname.match(/^\/http\/[0-9a-f]+/i);
+    const webvpnPrefix = prefixMatch ? prefixMatch[0] : "";
+    return window.location.origin + webvpnPrefix + "/jwglxt" + path;
+}
+
+/**
+ * 拼装课程备注。
+ * xm 只有姓名，kcmc 只有课程名，以下信息只存在于原始字段里，
+ * 放进备注方便用户核对：重修标记、选课备注（体育项目、微专业等）、周次原文。
+ */
+function buildCourseRemark(rawCourse) {
+    const parts = [];
+
+    const retakeFlag = String(rawCourse.cxbjmc || "").trim();
+    if (retakeFlag) {
+        parts.push(retakeFlag);
+    }
+
+    const selectionNote = String(rawCourse.xkbz || "").trim();
+    if (selectionNote) {
+        parts.push(selectionNote);
+    }
+
+    const weekDesc = String(rawCourse.zcd || "").trim();
+    if (weekDesc) {
+        parts.push(weekDesc);
+    }
+
+    return parts.join(" | ");
+}
+
+/**
+ * 解析 API 返回的 JSON 数据。
+ */
+function parseJsonData(jsonData) {
+    console.log("JS: parseJsonData 正在解析 JSON 数据...");
+
+    // 检查JSON结构：新的数据在 kbList 字段中
+    if (!jsonData || !Array.isArray(jsonData.kbList)) {
+        console.warn("JS: JSON 数据结构错误或缺少 kbList 字段。");
+        return [];
+    }
+
+    const rawCourseList = jsonData.kbList;
+    const finalCourseList = [];
+
+    for (const rawCourse of rawCourseList) {
+        // 关键字段检查：只有 kcmc(课名), xqj(星期), jcs(节次范围), zcd(周次描述) 是排课必需的。
+        // xm(教师) 与 cdmc(教室) 在实践课、线上课、未排地点的课程上可能为空，
+        // 缺这两项不影响排课，不能因此丢弃整门课程。
+        if (!rawCourse.kcmc || !rawCourse.xqj || !rawCourse.jcs || !rawCourse.zcd) {
+            continue;
+        }
+
+        const weeksArray = parseWeeks(rawCourse.zcd);
+
+        // 周次有效性检查
+        if (weeksArray.length === 0) {
+            continue;
+        }
+
+        // 解析节次范围，例如 "1-2"
+        const sectionParts = rawCourse.jcs.split('-');
+        const startSection = Number(sectionParts[0]);
+        const endSection = Number(sectionParts[sectionParts.length - 1]);
+
+        const day = Number(rawCourse.xqj); // xqj: 星期几 (周一为1, 周日为7)
+
+        // 数字有效性检查
+        if (isNaN(day) || isNaN(startSection) || isNaN(endSection) || day < 1 || day > 7 || startSection > endSection) {
+            continue;
+        }
+
+        const remark = buildCourseRemark(rawCourse);
+
+        const course = {
+            name: String(rawCourse.kcmc).trim(),
+            teacher: String(rawCourse.xm || "").trim(),
+            position: String(rawCourse.cdmc || "").trim(),
+            day: day,
+            startSection: startSection,
+            endSection: endSection,
+            weeks: weeksArray
+        };
+
+        if (remark) {
+            course.remark = remark;
+        }
+
+        finalCourseList.push(course);
+    }
+
+    finalCourseList.sort((a, b) =>
+        a.day - b.day ||
+        a.startSection - b.startSection ||
+        a.name.localeCompare(b.name)
+    );
+
+    console.log(`JS: JSON 数据解析完成，共找到 ${finalCourseList.length} 门课程。`);
+    return finalCourseList;
+}
+
+async function promptUserToStart() {
+    return await window.shiguangBridgePromise.showAlert(
+        "西南大学课表导入",
+        "导入前请确保您已从办事大厅(i.swu.edu.cn)登录并进入教务系统(jw.swu.edu.cn)课表查询页面。",
+        "好的，开始导入"
+    );
+}
+
+/**
+ * 从教务系统课表查询页读取学年与学期下拉选项。
+ * 学年以选中的一项为中心，取前 2 年 + 后 2 年，最多 5 项，避免列表过长。
+ */
+async function fetchAcademicOptions() {
+    const url = buildApiUrl("/kbcx/xskbcx_cxXskbcxIndex.html?gnmkdm=N2151");
+
+    try {
+        const response = await fetch(url, {
+            method: "GET",
+            credentials: "include"
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const htmlText = await response.text();
+        const doc = new DOMParser().parseFromString(htmlText, "text/html");
+
+        const allYearOptions = Array.from(doc.querySelectorAll("#xnm option"))
+            .filter((opt) => opt.value !== "")
+            .map((opt) => ({
+                value: opt.value,
+                text: opt.textContent.trim(),
+                selected: opt.selected
+            }));
+        const semesterOptions = Array.from(doc.querySelectorAll("#xqm option"))
+            .filter((opt) => opt.value !== "")
+            .map((opt) => ({
+                value: opt.value,
+                text: opt.textContent.trim(),
+                selected: opt.selected
+            }));
+
+        if (allYearOptions.length === 0 || semesterOptions.length === 0) {
+            return null;
+        }
+
+        const defaultSemesterIndex = (() => {
+            const i = semesterOptions.findIndex((opt) => opt.selected);
+            return i !== -1 ? i : 0;
+        })();
+
+        const selectedIndex = allYearOptions.findIndex((opt) => opt.selected);
+        if (selectedIndex === -1) {
+            return {
+                yearOptions: allYearOptions.slice(0, 5),
+                semesterOptions,
+                defaultYearIndex: 0,
+                defaultSemesterIndex
+            };
+        }
+
+        const start = Math.max(0, selectedIndex - 2);
+        const end = Math.min(allYearOptions.length, selectedIndex + 3);
+        return {
+            yearOptions: allYearOptions.slice(start, end),
+            semesterOptions,
+            defaultYearIndex: selectedIndex - start,
+            defaultSemesterIndex
+        };
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * 让用户依次点选学年与学期（带默认选中项），返回 API 所需的 xnm/xqm 代码。
+ * 无需手动输入，用户一路点下一步即可。
+ */
+async function selectAcademicYearAndSemester() {
+    const optionsData = await fetchAcademicOptions();
+    if (!optionsData) {
+        window.shiguangBridge.showToast("从教务系统读取学年学期失败，请确认登录状态有效。");
+        return null;
+    }
+
+    const { yearOptions, semesterOptions, defaultYearIndex, defaultSemesterIndex } = optionsData;
+
+    const yearIndex = await window.shiguangBridgePromise.showSingleSelection(
+        "选择学年",
+        JSON.stringify(yearOptions.map((item) => item.text)),
+        defaultYearIndex
+    );
+    if (yearIndex === null || yearIndex === -1) {
+        return null;
+    }
+    const academicYear = yearOptions[yearIndex].value;
+
+    const semesterIndex = await window.shiguangBridgePromise.showSingleSelection(
+        "选择学期",
+        JSON.stringify(semesterOptions.map((item) => item.text)),
+        defaultSemesterIndex
+    );
+    if (semesterIndex === null || semesterIndex === -1) {
+        return null;
+    }
+
     return {
-      name: item.name || item.courseName || item.kcmc || item.kcm || item['课程名称'] || '未命名课程',
-      teacher: item.teacher || item.teacherName || item.xm || item.jsxm || item['教师'] || '',
-      position: item.position || item.room || item.classroom || item.jxcd || item.cdmc || item['教室'] || '',
-      day,
-      startSection: start,
-      endSection: end,
-      weeks: Array.isArray(item.weeks) ? item.weeks : parseWeeks(text),
+        academicYear,
+        semesterCode: semesterOptions[semesterIndex].value
     };
-  }).filter((course) => course.day && course.startSection);
-
-  const main = async () => {
-    if (!window.shiguangBridgePromise) {
-      toast('当前环境不支持导入桥接，请在拾光课表 App 内执行。');
-      return;
-    }
-    const courses = [...parseCoursesFromJson(), ...parseCoursesFromDom()];
-    if (!courses.length) {
-      toast('未能从当前页面识别课程表。请先完成登录并进入西南大学教务课表页面，再执行导入脚本。');
-      return;
-    }
-    const totalWeeks = Math.max(20, ...courses.flatMap((course) => course.weeks || [0]));
-    await window.shiguangBridgePromise.saveCourseConfig(JSON.stringify({
-      semesterStartDate: null,
-      semesterTotalWeeks: totalWeeks,
-    }));
-    await window.shiguangBridgePromise.savePresetTimeSlots(JSON.stringify(DEFAULT_TIME_SLOTS));
-    await window.shiguangBridgePromise.saveImportedCourses(JSON.stringify(courses));
+}
+
+/**
+ * 获取所选学期的开学日期（第 1 周的日期）。
+ * 该接口按用户所选 xnm/xqm 返回对应学期的周历，能拿到比当前学期更准确的开班日期。
+ */
+async function fetchSemesterStartDate(academicYear, semesterCode) {
+    const url = buildApiUrl("/kbcx/xskbcxZccx_cxZcByXnxq.html?gnmkdm=N2154");
+
+    try {
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/x-www-form-urlencoded;charset=UTF-8"
+            },
+            body: `xnm=${academicYear}&xqm=${semesterCode}`,
+            credentials: "include"
+        });
+
+        if (response.ok) {
+            const json = await response.json();
+            if (Array.isArray(json) && json.length > 0) {
+                const firstWeekObj = json.find((item) => String(item.zs) === "1" || String(item.zsmc) === "1") || json[0];
+
+                const matchStr = String(firstWeekObj.rq || firstWeekObj.zcrq || firstWeekObj.ksrq || "").match(/(\d{4}-\d{2}-\d{2})/);
+                if (matchStr) {
+                    return matchStr[1];
+                }
+            }
+        }
+    } catch (e) {
+        // 获取失败不影响主流程
+    }
+    return null;
+}
+
+/**
+ * 计算课表配置。
+ *
+ * 应用侧的 saveCourseConfig 是整体覆盖而非字段级合并：没有传入的字段会被写成模型默认值，
+ * 其中 semesterStartDate 的默认值是 null，会把用户已经设置好的开学日期清空。
+ * 所以拿不到真实开学日期时返回 null，由调用方跳过整个配置保存，宁可不写也不要写坏。
+ */
+function buildCourseConfig(courses, startDate, firstDayOfWeek) {
+    if (!startDate) {
+        return null;
+    }
+
+    let maxWeek = 0;
+    for (const course of courses) {
+        for (const week of course.weeks) {
+            if (week > maxWeek) {
+                maxWeek = week;
+            }
+        }
+    }
+
+    return {
+        semesterStartDate: startDate,
+        // 只增不减：默认 20 周，课表里出现更大的周次时才扩展。
+        semesterTotalWeeks: Math.max(maxWeek, 20),
+        firstDayOfWeek: firstDayOfWeek
+    };
+}
+
+/**
+ * 请求和解析课程数据。
+ * 并行拉取课表 JSON 与所选学期开学日期。
+ */
+async function fetchAndParseCourses(academicYear, semesterCode) {
+    window.shiguangBridge.showToast("正在请求课表数据...");
+
+    const body = `xnm=${academicYear}&xqm=${semesterCode}&kzlx=ck&xsdm=&kclbdm=`;
+    const url = buildApiUrl("/kbcx/xskbcx_cxXsgrkb.html?gnmkdm=N2151");
+
+    const [courseResponse, startDate] = await Promise.all([
+        fetch(url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/x-www-form-urlencoded;charset=UTF-8"
+            },
+            body,
+            credentials: "include"
+        }),
+        fetchSemesterStartDate(academicYear, semesterCode)
+    ]);
+
+    try {
+        if (!courseResponse.ok) {
+            throw new Error(`网络请求失败。状态码: ${courseResponse.status} (${courseResponse.statusText})`);
+        }
+
+        const jsonText = await courseResponse.text();
+        let jsonData;
+        try {
+            jsonData = JSON.parse(jsonText);
+        } catch (e) {
+            console.error('JS: JSON 解析失败:', e);
+            window.shiguangBridge.showToast("数据返回格式错误，请确认已进入教务系统(jw.swu.edu.cn)课表查询页面（而非停留在办事大厅门户页），且登录状态有效。");
+            return null;
+        }
+
+        const courses = parseJsonData(jsonData);
+
+        if (courses.length === 0) {
+            window.shiguangBridge.showToast("未找到任何课程数据，请检查所选学年学期是否正确或本学期无课。");
+            return null;
+        }
+
+        console.log(`JS: 课程数据解析成功，共找到 ${courses.length} 门课程。`);
+
+        // qsxqj: 教务系统设置的一周起始星期几，缺失时按周一处理。
+        const rawFirstDay = Number(jsonData.qsxqj);
+        const firstDayOfWeek = (rawFirstDay >= 1 && rawFirstDay <= 7) ? rawFirstDay : 1;
+
+        return {
+            courses,
+            startDate,
+            firstDayOfWeek
+        };
+
+    } catch (error) {
+        window.shiguangBridge.showToast(`请求或解析失败: ${error.message}`);
+        console.error('JS: Fetch/Parse Error:', error);
+        return null;
+    }
+}
+
+async function saveCourses(parsedCourses) {
+    window.shiguangBridge.showToast(`正在保存 ${parsedCourses.length} 门课程...`);
+    try {
+        await window.shiguangBridgePromise.saveImportedCourses(JSON.stringify(parsedCourses, null, 2));
+        return true;
+    } catch (error) {
+        window.shiguangBridge.showToast(`课程保存失败: ${error.message}`);
+        console.error('JS: Save Courses Error:', error);
+        return false;
+    }
+}
+
+/**
+ * 只在能拿到真实开学日期时写入课表配置。
+ * 拿不到就完全不调用 saveCourseConfig —— 应用侧是整体覆盖，
+ * 传入不含 semesterStartDate 的配置会把用户已设置的开学日期清空。
+ */
+async function saveCourseConfigIfPossible(courses, startDate, firstDayOfWeek) {
+    const config = buildCourseConfig(courses, startDate, firstDayOfWeek);
+
+    if (!config) {
+        window.shiguangBridge.showToast("未取到本学期开学日期，已跳过课表配置，请在应用内手动设置开学日期。");
+        console.log("JS: 无可用开学日期，跳过 saveCourseConfig 以保留用户现有配置。");
+        return;
+    }
+
+    try {
+        await window.shiguangBridgePromise.saveCourseConfig(JSON.stringify(config));
+        window.shiguangBridge.showToast(
+            `课表配置更新成功！开学日期 ${config.semesterStartDate}，总周数 ${config.semesterTotalWeeks} 周。`
+        );
+    } catch (error) {
+        window.shiguangBridge.showToast(`课表配置保存失败: ${error.message}`);
+        console.error('JS: Save Config Error:', error);
+    }
+}
+
+// 西南大学统一作息时间（14 节，第 5 节 12:10 从中午开始，傍晚 17:50 后为第 11 节）
+const SWU_TIME_SLOTS = [
+    { number: 1, startTime: "08:00", endTime: "08:45" },
+    { number: 2, startTime: "08:55", endTime: "09:40" },
+    { number: 3, startTime: "10:00", endTime: "10:45" },
+    { number: 4, startTime: "10:55", endTime: "11:40" },
+    { number: 5, startTime: "12:10", endTime: "12:55" },
+    { number: 6, startTime: "13:05", endTime: "13:50" },
+    { number: 7, startTime: "14:00", endTime: "14:45" },
+    { number: 8, startTime: "14:55", endTime: "15:40" },
+    { number: 9, startTime: "15:50", endTime: "16:35" },
+    { number: 10, startTime: "16:55", endTime: "17:40" },
+    { number: 11, startTime: "17:50", endTime: "18:35" },
+    { number: 12, startTime: "19:20", endTime: "20:05" },
+    { number: 13, startTime: "20:15", endTime: "21:00" },
+    { number: 14, startTime: "21:10", endTime: "21:55" },
+];
+
+async function importPresetTimeSlots(timeSlots) {
+    if (timeSlots.length > 0) {
+        window.shiguangBridge.showToast(`正在导入 ${timeSlots.length} 个预设时间段...`);
+        try {
+            await window.shiguangBridgePromise.savePresetTimeSlots(JSON.stringify(timeSlots));
+            window.shiguangBridge.showToast("预设时间段导入成功！");
+        } catch (error) {
+            window.shiguangBridge.showToast("导入时间段失败: " + error.message);
+            console.error('JS: Save Time Slots Error:', error);
+        }
+    } else {
+        window.shiguangBridge.showToast("警告：时间段为空，未导入时间段信息。");
+    }
+}
+
+async function runImportFlow() {
+    const alertConfirmed = await promptUserToStart();
+    if (!alertConfirmed) {
+        window.shiguangBridge.showToast("用户取消了导入。");
+        return;
+    }
+
+    const selection = await selectAcademicYearAndSemester();
+    if (selection === null) {
+        window.shiguangBridge.showToast("导入已取消。");
+        return;
+    }
+    console.log(`JS: 已选择学年学期: ${selection.academicYear}/${selection.semesterCode}`);
+
+    const result = await fetchAndParseCourses(selection.academicYear, selection.semesterCode);
+    if (result === null) {
+        console.log("JS: 课程获取或解析失败，流程终止。");
+        return;
+    }
+    const { courses, startDate, firstDayOfWeek } = result;
+
+    const saveResult = await saveCourses(courses);
+    if (!saveResult) {
+        console.log("JS: 课程保存失败，流程终止。");
+        return;
+    }
+
+    await saveCourseConfigIfPossible(courses, startDate, firstDayOfWeek);
+
+    await importPresetTimeSlots(SWU_TIME_SLOTS);
+
+    window.shiguangBridge.showToast(`课程导入成功，共导入 ${courses.length} 门课程！`);
+    console.log("JS: 整个导入流程执行完毕并成功。");
     window.shiguangBridge.notifyTaskCompletion();
-  };
+}
 
-  main().catch((error) => {
-    console.error(error);
-    toast(`西南大学课表导入失败：${error.message || error}`);
-  });
-})();
+runImportFlow();