Files
class-schedule/shiguang_warehouse/resources/GDOU/gdou.js
T
2026-09-20 13:33:09 +08:00

666 lines
23 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 广东海洋大学教务课表导入适配
* @date 2026-08-27
* @author Mccurtain
* @version 2.0
*/
(function () {
// ==================== 常量 ====================
// venues 为整栋楼使用特殊作息的楼名(包含匹配,如 "实验楼" 会命中 "实验楼301"、"网球场(实验楼东面)");
// venuePatterns 为楼名简写正则(如海滨 "实"+房间号 = 实验楼简写,实506-1计算机(2)室);
// outdoorKeywords 为特殊作息的室外场地关键词。
const CAMPUS_CONFIGS = [
{
id: "huguang",
label: "湖光校区",
venues: ["广学楼", "明德楼"],
venuePatterns: [],
outdoorKeywords: []
},
{
id: "haibin",
label: "海滨校区",
venues: ["实验楼"],
venuePatterns: [{ name: "实验楼简写", pattern: /^实\d/ }],
outdoorKeywords: ["球场", "东面", "南面", "西面", "北面"]
}
];
// 全校统一作息时间(1-10 节),未指定特殊作息的教室使用
const TimeSlots = [
{ number: 1, startTime: "08:10", endTime: "08:55" },
{ number: 2, startTime: "09:00", endTime: "09:45" },
{ number: 3, startTime: "10:15", endTime: "11:00" },
{ number: 4, startTime: "11:05", endTime: "11:50" },
{ number: 5, startTime: "14:30", endTime: "15:15" },
{ number: 6, startTime: "15:20", endTime: "16:05" },
{ number: 7, startTime: "16:30", endTime: "17:15" },
{ number: 8, startTime: "17:20", endTime: "18:05" },
{ number: 9, startTime: "19:30", endTime: "20:15" },
{ number: 10, startTime: "20:25", endTime: "21:10" }
];
// 指定楼/室外场地的特殊作息时间块(连堂)
const SPECIAL_TIME_BLOCKS = [
{ startSection: 3, endSection: 4, startTime: "10:05", endTime: "11:35" },
{ startSection: 7, endSection: 8, startTime: "16:25", endTime: "17:50" }
];
// ==================== 解析函数 ====================
/**
* 将周次字符串展开为具体周次数组
* 支持范围(如 1-16周)、单周(如 6周)、单双周(如 1-8周(单))、
* 以及逗号分隔的多种写法混合,全角逗号也会被兼容
*/
function parseWeeks(weekStr) {
if (!weekStr) return [];
const groups = String(weekStr).replace(/,/g, ',').split(',');
const weeks = [];
for (const group of groups) {
const item = group.trim();
// 先尝试匹配 "起-止周",再尝试匹配单个周次
const rangeMatch = item.match(/(\d+)\s*-\s*(\d+)\s*周?/);
const singleMatch = item.match(/^(\d+)\s*周?/);
let start = 0;
let end = 0;
let matched = false;
if (rangeMatch) {
start = Number(rangeMatch[1]);
end = Number(rangeMatch[2]);
matched = true;
} else if (singleMatch) {
start = end = Number(singleMatch[1]);
matched = true;
}
if (matched && start >= 1 && end >= start) {
const isOddOnly = item.includes('(单)');
const isEvenOnly = item.includes('(双)');
for (let w = start; w <= end; w++) {
if (isOddOnly && w % 2 === 0) continue; // 单周:跳过偶数周
if (isEvenOnly && w % 2 !== 0) continue; // 双周:跳过奇数周
weeks.push(w);
}
}
}
return [...new Set(weeks)].sort((a, b) => a - b);
}
/**
* 解析节次字段,如 "1-2"、"3"、"1-2节",得到起止节次
* 格式无法识别或数值不合法时返回 null
*/
function parseSectionRange(sectionStr) {
const text = sectionStr == null ? '' : String(sectionStr);
const match = text.match(/^\s*(?:第)?(\d+)\s*(?:-\s*(\d+))?\s*节?\s*$/);
if (!match) return null;
const startSection = Number(match[1]);
const endSection = Number(match[2] || match[1]);
if (!Number.isInteger(startSection) || !Number.isInteger(endSection) ||
startSection < 1 || endSection < startSection) {
return null;
}
return { startSection, endSection };
}
// 提前公选课课程名
function normalizeCourseName(rawName) {
const name = String(rawName).trim();
if (!name) return name;
const match = name.match(/^[((]([^()()]+)[))]\s*/);
if (!match) return name;
const rest = name.slice(match[0].length);
if (!rest) return name;
return `${rest}(${match[1]})`;
}
/**
* 节次与周次合并去重函数
* @param {Array<Object>} courses 原始解析课程数组
* @returns {Array<Object>} 合并去重后的课程数组
*/
function mergeAndDistinctCourses(courses) {
if (!Array.isArray(courses) || courses.length <= 1) return courses;
// 规范化数据,周次统一排序,便于比较
const list = courses.map(c => ({
...c,
name: c.name || '',
teacher: c.teacher || '',
position: c.position || '',
weeks: Array.isArray(c.weeks) ? [...c.weeks].sort((a, b) => a - b) : []
}));
// 第一步:按课程、周次排序后合并连续节次,同时剔除完全重复项
list.sort((a, b) =>
a.name.localeCompare(b.name) ||
a.teacher.localeCompare(b.teacher) ||
a.position.localeCompare(b.position) ||
(a.day || 0) - (b.day || 0) ||
a.weeks.join(',').localeCompare(b.weeks.join(',')) ||
(a.startSection || 0) - (b.startSection || 0)
);
const step1 = [];
let current = list[0];
for (let i = 1; i < list.length; i++) {
const next = list[i];
const isSameCourse =
current.name === next.name &&
current.teacher === next.teacher &&
current.position === next.position &&
current.day === next.day &&
current.weeks.join(',') === next.weeks.join(',');
if (isSameCourse && current.endSection + 1 === next.startSection) {
// 节次紧邻,延长结束节次:1-2 节 + 3-4 节 -> 1-4 节
current.endSection = next.endSection;
} else if (isSameCourse && current.startSection === next.startSection && current.endSection === next.endSection) {
// 完全重复的记录,跳过
continue;
} else {
step1.push(current);
current = next;
}
}
step1.push(current);
// 第二步:按课程、节次排序后合并相同节次的周次
step1.sort((a, b) =>
a.name.localeCompare(b.name) ||
a.teacher.localeCompare(b.teacher) ||
a.position.localeCompare(b.position) ||
(a.day || 0) - (b.day || 0) ||
(a.startSection || 0) - (b.startSection || 0) ||
(a.endSection || 0) - (b.endSection || 0)
);
const step2 = [];
let cur = step1[0];
for (let i = 1; i < step1.length; i++) {
const nxt = step1[i];
const isSameSection =
cur.name === nxt.name &&
cur.teacher === nxt.teacher &&
cur.position === nxt.position &&
cur.day === nxt.day &&
cur.startSection === nxt.startSection &&
cur.endSection === nxt.endSection;
if (isSameSection) {
// 周次取并集:1-8 周 + 9-16 周 -> 1-16 周
cur.weeks = Array.from(new Set([...cur.weeks, ...nxt.weeks])).sort((a, b) => a - b);
} else {
step2.push(cur);
cur = nxt;
}
}
step2.push(cur);
return step2;
}
// ==================== 特殊作息处理 ====================
/**
* 判断位置是否命中特殊场地(指定楼或室外场地),返回命中的类型与关键词
* 楼名与室外关键词取并集,包含任一即可;命中者打标特殊作息
* @returns {{type: 'venue'|'outdoor', key: string}|null}
*/
function matchesSpecialVenue(positionText, campusConfig) {
const venueHit = campusConfig.venues.find(venue => positionText.includes(venue));
if (venueHit) return { type: 'venue', key: venueHit };
const patternHit = (campusConfig.venuePatterns || []).find(p => p.pattern.test(positionText));
if (patternHit) return { type: 'venue', key: patternHit.name };
const outdoorHit = campusConfig.outdoorKeywords.find(keyword => positionText.includes(keyword));
if (outdoorHit) return { type: 'outdoor', key: outdoorHit };
return null;
}
/**
* 判断课程是否命中特殊作息(正向策略)
* 命中指定楼/室外场地的课程,在节次恰为特殊时间块(3-4/7-8 节)时打标特殊时间;
* 其他普通教室不打标,使用 TimeSlots 全校统一作息。
* 返回对象附带 reason 判定原因,供内部诊断与本地验证脚本使用(不写入导出课程)。
*/
function getCustomTime(position, startSection, endSection, campusConfig) {
const positionText = position == null ? '' : String(position);
const hit = matchesSpecialVenue(positionText, campusConfig);
if (!hit) return { marked: false, reason: 'no-block' };
const block = SPECIAL_TIME_BLOCKS.find(
b => b.startSection === startSection && b.endSection === endSection
);
if (block) return { marked: true, startTime: block.startTime, endTime: block.endTime, reason: `special-${hit.type}:${hit.key}` };
return { marked: false, reason: `special-${hit.type}:${hit.key}-no-block` };
}
// ==================== 数据解析 ====================
/**
* 解析正方 v9 课表接口返回的 JSON,提取有效课程
* 数据位于 kbList 字段;课程名/星期/节次/周次缺失或不合法的记录会被跳过,
* 教师、教室允许为空
*/
function parseJsonData(jsonData, campusConfig) {
if (!jsonData || !Array.isArray(jsonData.kbList)) return [];
const courses = [];
for (const raw of jsonData.kbList) {
if (!raw || typeof raw !== 'object') continue;
if (!raw.kcmc || raw.xqj == null || raw.jcs == null || raw.zcd == null) continue;
const weeks = parseWeeks(raw.zcd);
if (weeks.length === 0) continue;
const sectionRange = parseSectionRange(raw.jcs);
if (!sectionRange) continue;
const day = Number(raw.xqj); // 1=周一 ... 7=周日
if (isNaN(day) || day < 1 || day > 7) continue;
// 直接基于原始接口字段 cdmc 构造课程位置
const position = raw.cdmc == null ? '' : String(raw.cdmc).trim();
const course = {
name: normalizeCourseName(raw.kcmc),
teacher: raw.xm == null ? '' : String(raw.xm).trim(),
position,
day,
startSection: sectionRange.startSection,
endSection: sectionRange.endSection,
weeks
};
// 边解析边判断:直接对原始教室字段 cdmc 判断是否命中特殊作息,
// 命中则在写入课程对象的同时打好 isCustomTime 标记,App 将优先显示自定义时间
const customTime = getCustomTime(position, course.startSection, course.endSection, campusConfig);
if (customTime.marked) {
course.isCustomTime = true;
course.customStartTime = customTime.startTime;
course.customEndTime = customTime.endTime;
}
courses.push(course);
}
const mergedCourses = mergeAndDistinctCourses(courses);
// 合并可能改变节次区间(如 1-2 节 + 3-4 节 -> 1-4 节),对已打标课程做最终校验:
// 合并后的区间不再精确命中特殊时间块时,撤销打标,避免特殊时间被错误扩散
return mergedCourses.map(course => {
if (!course.isCustomTime) return course;
const customTime = getCustomTime(course.position, course.startSection, course.endSection, campusConfig);
if (!customTime.marked) {
const plain = { ...course };
delete plain.isCustomTime;
delete plain.customStartTime;
delete plain.customEndTime;
return plain;
}
return course;
});
}
// ==================== 日期工具 ====================
/**
* 把教务返回的日期字段规范为 yyyy-MM-dd
* 兼容 "-"、"."、"/" 以及中文"年月日"等分隔写法
*/
function normalizeStartDate(value) {
const match = String(value || "").match(/(\d{4})[-\/.年](\d{1,2})[-\/.月](\d{1,2})/);
if (!match) return null;
return `${match[1]}-${match[2].padStart(2, "0")}-${match[3].padStart(2, "0")}`;
}
/**
* 在校历响应中查找第 1 周开学日期
* 兼容顶层数组、data/list/rows 等包装对象,以及 zrq/zcrq/rq/ksrq 字段
*/
function findSemesterStartDate(value) {
if (value == null) return null;
if (typeof value !== "object") return normalizeStartDate(value);
if (Array.isArray(value)) {
const firstWeek = value.find(item =>
item && typeof item === "object" &&
(String(item.zs) === "1" || String(item.zsmc) === "1")
) || value[0];
const found = findSemesterStartDate(firstWeek);
if (found) return found;
for (const item of value) {
const date = findSemesterStartDate(item);
if (date) return date;
}
return null;
}
for (const field of ["zrq", "zcrq", "rq", "ksrq"]) {
const date = normalizeStartDate(value[field]);
if (date) return date;
}
for (const item of Object.values(value)) {
const date = findSemesterStartDate(item);
if (date) return date;
}
return null;
}
// ==================== 教务接口 ====================
/**
* 读取课表查询页里的学年/学期下拉选项
* 成功返回 { yearOptions, semesterOptions, defaultYearIndex, defaultSemesterIndex };
* 读取失败返回 null,由调用方回退到默认值
*/
async function fetchAcademicOptions() {
const url = "https://jw.gdou.edu.cn/kbcx/xskbcx_cxXskbcxIndex.html?gnmkdm=N2151&layout=default";
try {
const response = await fetch(url, { method: "GET", credentials: "include" });
if (!response.ok) return null;
const doc = new DOMParser().parseFromString(await response.text(), "text/html");
// 解析单个下拉框;默认选中项优先跟随 select 当前值,其次取 selected 属性
const readSelect = (select) => {
if (!select) return null;
const options = Array.from(select.querySelectorAll("option"))
.map(opt => ({ value: opt.value, text: opt.textContent.trim() || opt.value }))
.filter(opt => opt.value !== "");
if (options.length === 0) return null;
const valueIndex = options.findIndex(opt => opt.value === select.value);
const selectedIndex = options.findIndex(opt => opt.selected);
return { options, defaultIndex: valueIndex !== -1 ? valueIndex : Math.max(0, selectedIndex) };
};
const yearData = readSelect(doc.querySelector("#xnm"));
const semesterData = readSelect(doc.querySelector("#xqm"));
if (!yearData || !semesterData) return null;
return {
yearOptions: yearData.options,
semesterOptions: semesterData.options,
defaultYearIndex: yearData.defaultIndex,
defaultSemesterIndex: semesterData.defaultIndex
};
} catch (e) {
return null;
}
}
/**
* 查询指定学期的周次安排,取出第 1 周的日期作为开学日期,并返回该学期总周数
* 接口失败时返回 null,不影响主流程
*/
async function fetchSemesterInfo(academicYear, semesterCode) {
const url = "https://jw.gdou.edu.cn/kbcx/xskbcxZccx_cxZcByXnxq.html?gnmkdm=N2154";
const body = `xnm=${encodeURIComponent(academicYear)}&xqm=${encodeURIComponent(semesterCode)}`;
try {
const response = await fetch(url, {
method: "POST",
headers: {
"accept": "application/json, text/javascript, */*; q=0.01",
"Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
"x-requested-with": "XMLHttpRequest"
},
body,
credentials: "include"
});
if (!response.ok) return null;
const weeks = await response.json();
if (!Array.isArray(weeks) || weeks.length === 0) return null;
return {
startDate: findSemesterStartDate(weeks),
totalWeeks: weeks.length
};
} catch (e) {
return null;
}
}
/**
* 请求课表接口并解析课程,同时并行获取学期信息
* 成功返回 { courses, config },失败返回 null
*/
async function fetchAndParseCourses(academicYear, semesterCode, campusConfig) {
const body = `xnm=${encodeURIComponent(academicYear)}&xqm=${encodeURIComponent(semesterCode)}&kzlx=ck&xsdm=&kclbdm=`;
const courseUrl = "https://jw.gdou.edu.cn/kbcx/xskbcx_cxXsgrkb.html?gnmkdm=N2151";
const [courseResponse, semesterInfo] = await Promise.all([
fetch(courseUrl, {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8" },
body,
credentials: "include"
}),
fetchSemesterInfo(academicYear, semesterCode)
]);
try {
if (!courseResponse.ok) {
window.shiguangBridge.showToast(`课表请求失败:HTTP ${courseResponse.status}`);
return null;
}
const courses = parseJsonData(JSON.parse(await courseResponse.text()), campusConfig);
if (courses.length === 0) {
window.shiguangBridge.showToast("未查询到课表数据,请检查学年/学期选择或登录状态。");
return null;
}
// 总周数取接口返回值与课程最大周次中的较大者,保证不截断课表
const maxCourseWeek = courses.reduce((max, c) => Math.max(max, ...c.weeks), 0);
return {
courses,
config: {
semesterStartDate: semesterInfo ? semesterInfo.startDate : null,
semesterTotalWeeks: Math.max(maxCourseWeek, semesterInfo ? semesterInfo.totalWeeks : 20)
}
};
} catch (e) {
window.shiguangBridge.showToast("获取课表失败,请确认已登录且网络可访问 jw.gdou.edu.cn。");
return null;
}
}
// ==================== 交互 ====================
/**
* 按当前月份推断学年起始年份:9 月及以后属于新学年,其余月份沿用上一学年
*/
function getDefaultAcademicYear(date = new Date()) {
const currentYear = date.getFullYear();
return (date.getMonth() >= 8 ? currentYear : currentYear - 1).toString();
}
/**
* 弹出导入确认提示,说明使用前提
*/
async function promptUserToStart() {
return await window.shiguangBridgePromise.showAlert(
"广东海洋大学教务系统课表导入",
"导入前请确认已在浏览器中登录教务系统(jw.gdou.edu.cn)。\n脚本将通过接口直接获取课表,无需停留在特定页面。",
"好的,开始导入"
);
}
/**
* 弹出校区选择框,决定使用哪套特殊作息规则
* 取消返回 null,由调用方终止流程
*/
async function selectCampus() {
const campusIndex = await window.shiguangBridgePromise.showSingleSelection(
"选择校区",
JSON.stringify(CAMPUS_CONFIGS.map(item => item.label)),
0
);
if (campusIndex === null || campusIndex === -1) return null;
return CAMPUS_CONFIGS[campusIndex];
}
/**
* 依次弹出学年、学期选择框
* 选项优先来自教务系统;若读取失败,则按当前月份给出默认学年,
* 学期码(3=第一学期,12=第二学期)
*/
async function selectAcademicYearAndSemester() {
const options = await fetchAcademicOptions();
let yearOptions;
let semesterOptions;
let defaultYearIndex;
let defaultSemesterIndex;
if (options) {
({ yearOptions, semesterOptions, defaultYearIndex, defaultSemesterIndex } = options);
} else {
const year = getDefaultAcademicYear();
const isFirstSemester = new Date().getMonth() >= 8;
yearOptions = [{ value: year, text: `${year}-${Number(year) + 1}` }];
semesterOptions = [
{ value: "3", text: "第一学期" },
{ value: "12", text: "第二学期" }
];
defaultYearIndex = 0;
defaultSemesterIndex = isFirstSemester ? 0 : 1;
window.shiguangBridge.showToast("未读取到教务系统学年学期选项,已使用默认值,请核对。");
}
const yearIndex = await window.shiguangBridgePromise.showSingleSelection(
"选择学年",
JSON.stringify(yearOptions.map(item => item.text)),
defaultYearIndex
);
if (yearIndex === null || yearIndex === -1) return null;
const semesterIndex = await window.shiguangBridgePromise.showSingleSelection(
"选择学期",
JSON.stringify(semesterOptions.map(item => item.text)),
defaultSemesterIndex
);
if (semesterIndex === null || semesterIndex === -1) return null;
return {
academicYear: yearOptions[yearIndex].value,
semesterCode: semesterOptions[semesterIndex].value
};
}
// ==================== 保存 ====================
async function saveCourses(courses) {
try {
await window.shiguangBridgePromise.saveImportedCourses(JSON.stringify(courses));
return true;
} catch (error) {
window.shiguangBridge.showToast(`课程保存失败: ${error.message}`);
return false;
}
}
/**
* 将预设作息时间导入 App
*/
async function importPresetTimeSlots(timeSlots) {
if (timeSlots.length === 0) {
window.shiguangBridge.showToast("警告:时间段为空,未导入时间段信息。");
return;
}
try {
await window.shiguangBridgePromise.savePresetTimeSlots(JSON.stringify(timeSlots));
window.shiguangBridge.showToast("预设时间段导入成功!");
} catch (error) {
window.shiguangBridge.showToast("导入时间段失败: " + error.message);
}
}
// ==================== 主流程 ====================
async function runImportFlow() {
// 1. 确认导入
const confirmed = await promptUserToStart();
if (!confirmed) {
window.shiguangBridge.showToast("用户取消了导入。");
return;
}
// 2. 选择学年学期
const selection = await selectAcademicYearAndSemester();
if (!selection) {
window.shiguangBridge.showToast("未选择学年学期,导入流程终止。");
return;
}
// 3. 选择校区(决定特殊作息规则)
const campusConfig = await selectCampus();
if (!campusConfig) {
window.shiguangBridge.showToast("未选择校区,导入流程终止。");
return;
}
// 4. 拉取并解析课程
const result = await fetchAndParseCourses(selection.academicYear, selection.semesterCode, campusConfig);
if (result === null) return;
const { courses, config } = result;
// 5. 保存课程
if (!(await saveCourses(courses))) return;
// 6. 保存课表配置(开学日期、总周数)
try {
await window.shiguangBridgePromise.saveCourseConfig(JSON.stringify(config));
let msg = `课表配置更新成功!总周数:${config.semesterTotalWeeks}周。`;
if (config.semesterStartDate) msg += ` 开学日期:${config.semesterStartDate}`;
window.shiguangBridge.showToast(msg);
} catch (error) {
window.shiguangBridge.showToast(`课表配置保存失败: ${error.message}`);
}
// 7. 导入预设作息时间
await importPresetTimeSlots(TimeSlots);
window.shiguangBridge.showToast(`课程导入成功,共导入 ${courses.length} 门课程!`);
window.shiguangBridge.showToast(`若课程时间有误,请提交issue或联系开发者!`);
window.shiguangBridge.notifyTaskCompletion();
}
runImportFlow();
})();