⚒️ 重大重构 LoveACE V2

引入了 mongodb
对数据库进行了一定程度的数据加密
性能改善
代码简化
统一错误模型和响应
使用 apifox 作为文档

loveace/router/endpoint/jwc/utils/aspnet_form_parser.py

@@ -0,0 +1,96 @@
+"""
+ASP.NET 表单解析器
+用于从 ASP.NET 页面中提取动态表单数据
+"""
+
+import re
+from typing import Dict, Optional, Any
+
+from bs4 import BeautifulSoup
+
+
+class ASPNETFormParser:
+    """ASP.NET 表单解析器"""
+
+    @staticmethod
+    def extract_form_data(html_content: str) -> Dict[str, str]:
+        """
+        从 ASP.NET 页面 HTML 中提取表单数据
+
+        Args:
+            html_content: HTML 页面内容
+
+        Returns:
+            包含表单字段的字典
+        """
+
+        return ASPNETFormParser._extract_with_beautifulsoup(html_content)
+
+    @staticmethod
+    def _extract_with_beautifulsoup(html_content: str) -> Dict[str, str]:
+        """
+        使用 BeautifulSoup 提取表单数据
+
+        Args:
+            html_content: HTML 页面内容
+
+        Returns:
+            包含表单字段的字典
+        """
+        form_data = {}
+
+        # 使用 BeautifulSoup 解析 HTML
+        soup = BeautifulSoup(html_content, "lxml")
+
+        # 查找表单
+        form = soup.find("form", {"method": "post"})
+        if not form:
+            raise ValueError("未找到 POST 表单")
+
+        # 提取隐藏字段
+        hidden_fields = [
+            "__EVENTTARGET",
+            "__EVENTARGUMENT",
+            "__LASTFOCUS",
+            "__VIEWSTATE",
+            "__VIEWSTATEGENERATOR",
+            "__EVENTVALIDATION",
+        ]
+
+        for field_name in hidden_fields:
+            input_element = form.find("input", {"name": field_name})
+            if input_element and input_element.get("value"):
+                form_data[field_name] = input_element.get("value")
+            else:
+                form_data[field_name] = ""
+
+        # 添加其他表单字段的默认值
+        form_data.update(
+            {
+                "ctl00$ContentPlaceHolder1$ContentPlaceHolder2$ddlSslb": "%",
+                "ctl00$ContentPlaceHolder1$ContentPlaceHolder2$txtSsmc": "",
+                "ctl00$ContentPlaceHolder1$ContentPlaceHolder2$gvSb$ctl28$txtNewPageIndex": "1",
+            }
+        )
+
+        return form_data
+
+    @staticmethod
+    def get_awards_list_form_data(html_content: str) -> Dict[str, str]:
+        """
+        获取已申报奖项列表页面的表单数据
+
+        Args:
+            html_content: HTML 页面内容
+
+        Returns:
+            用于请求已申报奖项的表单数据
+        """
+        base_form_data = ASPNETFormParser.extract_form_data(html_content)
+
+        # 设置 EVENTTARGET 为"已申报奖项"选项卡
+        base_form_data["__EVENTTARGET"] = (
+            "ctl00$ContentPlaceHolder1$ContentPlaceHolder2$DataList1$ctl01$LinkButton1"
+        )
+
+        return base_form_data

loveace/router/endpoint/jwc/utils/competition.py

@@ -0,0 +1,267 @@
+from typing import Optional
+
+from bs4 import BeautifulSoup
+
+from loveace.router.endpoint.jwc.model.competition import (
+    AwardProject,
+    CompetitionAwardsResponse,
+    CompetitionCreditsSummaryResponse,
+    CompetitionFullResponse,
+    CreditsSummary,
+)
+
+
+class CompetitionInfoParser:
+    """
+    创新创业管理平台信息解析器
+
+    功能：
+        - 解析获奖项目列表（表格数据）
+        - 解析学分汇总信息
+        - 提取学生基本信息
+    """
+
+    def __init__(self, html_content: str):
+        """
+        初始化解析器
+
+        参数:
+            html_content: HTML页面内容字符串
+        """
+        self.soup = BeautifulSoup(html_content, "html.parser")
+
+    def parse_awards(self) -> CompetitionAwardsResponse:
+        """
+        解析获奖项目列表
+
+        返回:
+            CompetitionAwardsResponse: 包含获奖项目列表的响应对象
+        """
+        # 解析学生ID
+        student_id = self._parse_student_id()
+
+        # 解析项目列表
+        projects = self._parse_projects()
+
+        response = CompetitionAwardsResponse(
+            student_id=student_id,
+            total_count=len(projects),
+            awards=projects,
+        )
+
+        return response
+
+    def parse_credits_summary(self) -> CompetitionCreditsSummaryResponse:
+        """
+        解析学分汇总信息
+
+        返回:
+            CompetitionCreditsSummaryResponse: 包含学分汇总信息的响应对象
+        """
+        # 解析学生ID
+        student_id = self._parse_student_id()
+
+        # 解析学分汇总
+        credits_summary = self._parse_credits_summary()
+
+        response = CompetitionCreditsSummaryResponse(
+            student_id=student_id,
+            credits_summary=credits_summary,
+        )
+
+        return response
+
+    def parse_full_competition_info(self) -> CompetitionFullResponse:
+        """
+        解析完整的学科竞赛信息（获奖项目 + 学分汇总）
+
+        一次性解析HTML，同时提取获奖项目列表和学分汇总信息，
+        减少网络IO和数据库查询次数
+
+        返回:
+            CompetitionFullResponse: 包含完整竞赛信息的响应对象
+        """
+        # 解析学生ID
+        student_id = self._parse_student_id()
+
+        # 解析项目列表
+        projects = self._parse_projects()
+
+        # 解析学分汇总
+        credits_summary = self._parse_credits_summary()
+
+        response = CompetitionFullResponse(
+            student_id=student_id,
+            total_awards_count=len(projects),
+            awards=projects,
+            credits_summary=credits_summary,
+        )
+
+        return response
+
+    def _parse_student_id(self) -> str:
+        """
+        解析学生基本信息 - 学生ID/工号
+
+        返回:
+            str: 学生ID，如果未找到返回空字符串
+        """
+        student_span = self.soup.find("span", id="ContentPlaceHolder1_lblXM")
+        if student_span:
+            text = student_span.get_text(strip=True)
+            # 格式: "欢迎您：20244787"
+            if "：" in text:
+                return text.split("：")[1].strip()
+        return ""
+
+    def _parse_projects(self) -> list:
+        """
+        解析获奖项目列表
+
+        数据来源: 页面中ID为 ContentPlaceHolder1_ContentPlaceHolder2_gvHj 的表格
+
+        表格结构:
+            - 第一行为表头
+            - 后续行为项目数据
+            - 包含15列数据
+
+        返回:
+            list[AwardProject]: 获奖项目列表
+        """
+        projects = []
+
+        # 查找项目列表表格
+        table = self.soup.find(
+            "table", id="ContentPlaceHolder1_ContentPlaceHolder2_gvHj"
+        )
+        if not table:
+            return projects
+
+        rows = table.find_all("tr")
+        # 跳过表头行（第一行）
+        for row in rows[1:]:
+            cells = row.find_all("td")
+            if len(cells) < 9:  # 至少需要9列数据
+                continue
+
+            try:
+                project = AwardProject(
+                    project_id=cells[0].get_text(strip=True),
+                    project_name=cells[1].get_text(strip=True),
+                    level=cells[2].get_text(strip=True),
+                    grade=cells[3].get_text(strip=True),
+                    award_date=cells[4].get_text(strip=True),
+                    applicant_id=cells[5].get_text(strip=True),
+                    applicant_name=cells[6].get_text(strip=True),
+                    order=int(cells[7].get_text(strip=True)),
+                    credits=float(cells[8].get_text(strip=True)),
+                    bonus=float(cells[9].get_text(strip=True)),
+                    status=cells[10].get_text(strip=True),
+                    verification_status=cells[11].get_text(strip=True),
+                )
+                projects.append(project)
+            except (ValueError, IndexError):
+                # 数据格式异常，记录但继续处理
+                continue
+
+        return projects
+
+    def _parse_credits_summary(self) -> Optional[CreditsSummary]:
+        """
+        解析学分汇总信息
+
+        数据来源: 页面中的学分汇总表中的各类学分 span 元素
+
+        提取内容:
+            - 学科竞赛学分
+            - 科研项目学分
+            - 可转竞赛类学分
+            - 创新创业实践学分
+            - 能力资格认证学分
+            - 其他项目学分
+
+        返回:
+            CreditsSummary: 学分汇总对象，如果无法解析则返回 None
+        """
+        discipline_competition_credits = None
+        scientific_research_credits = None
+        transferable_competition_credits = None
+        innovation_practice_credits = None
+        ability_certification_credits = None
+        other_project_credits = None
+
+        # 查找学科竞赛学分
+        xkjs_span = self.soup.find(
+            "span", id="ContentPlaceHolder1_ContentPlaceHolder2_lblXkjsxf"
+        )
+        if xkjs_span:
+            text = xkjs_span.get_text(strip=True)
+            discipline_competition_credits = self._parse_credit_value(text)
+
+        # 查找科研项目学分
+        ky_span = self.soup.find(
+            "span", id="ContentPlaceHolder1_ContentPlaceHolder2_lblKyxf"
+        )
+        if ky_span:
+            text = ky_span.get_text(strip=True)
+            scientific_research_credits = self._parse_credit_value(text)
+
+        # 查找可转竞赛类学分
+        kzjsl_span = self.soup.find(
+            "span", id="ContentPlaceHolder1_ContentPlaceHolder2_lblKzjslxf"
+        )
+        if kzjsl_span:
+            text = kzjsl_span.get_text(strip=True)
+            transferable_competition_credits = self._parse_credit_value(text)
+
+        # 查找创新创业实践学分
+        cxcy_span = self.soup.find(
+            "span", id="ContentPlaceHolder1_ContentPlaceHolder2_lblCxcyxf"
+        )
+        if cxcy_span:
+            text = cxcy_span.get_text(strip=True)
+            innovation_practice_credits = self._parse_credit_value(text)
+
+        # 查找能力资格认证学分
+        nlzg_span = self.soup.find(
+            "span", id="ContentPlaceHolder1_ContentPlaceHolder2_lblNlzgxf"
+        )
+        if nlzg_span:
+            text = nlzg_span.get_text(strip=True)
+            ability_certification_credits = self._parse_credit_value(text)
+
+        # 查找其他项目学分
+        qt_span = self.soup.find(
+            "span", id="ContentPlaceHolder1_ContentPlaceHolder2_lblQtxf"
+        )
+        if qt_span:
+            text = qt_span.get_text(strip=True)
+            other_project_credits = self._parse_credit_value(text)
+
+        return CreditsSummary(
+            discipline_competition_credits=discipline_competition_credits,
+            scientific_research_credits=scientific_research_credits,
+            transferable_competition_credits=transferable_competition_credits,
+            innovation_practice_credits=innovation_practice_credits,
+            ability_certification_credits=ability_certification_credits,
+            other_project_credits=other_project_credits,
+        )
+
+    @staticmethod
+    def _parse_credit_value(text: str) -> Optional[float]:
+        """
+        解析学分值
+
+        参数:
+            text: 文本值，可能为"0", "16.60", "无"等
+
+        返回:
+            float: 学分值，如果为"无"或无法解析则返回 None
+        """
+        text = text.strip()
+        if text == "无" or text == "":
+            return None
+        try:
+            return float(text)
+        except ValueError:
+            return None

loveace/router/endpoint/jwc/utils/exam.py

@@ -0,0 +1,337 @@
+import time
+from json import JSONDecodeError
+from typing import List, Optional
+
+from bs4 import BeautifulSoup
+
+from loveace.router.endpoint.jwc.model.base import JWCConfig
+from loveace.router.endpoint.jwc.model.exam import (
+    ExamInfoResponse,
+    ExamScheduleItem,
+    OtherExamRecord,
+    OtherExamResponse,
+    SeatInfo,
+    UnifiedExamInfo,
+)
+from loveace.service.remote.aufe import AUFEConnection
+
+ENDPOINTS = {
+    "school_exam_pre_request": "/student/examinationManagement/examPlan/index",
+    "school_exam_request": "/student/examinationManagement/examPlan/detail",
+    "seat_info": "/student/examinationManagement/examPlan/index",
+    "other_exam_record": "/student/examinationManagement/othersExamPlan/queryScores?sf_request_type=ajax",
+}
+
+
+# +++++===== 考试信息前置方法 =====+++++ #
+async def fetch_school_exam_schedule(
+    start_date: str, end_date: str, conn: AUFEConnection
+) -> List[ExamScheduleItem]:
+    """
+    获取校统考考试安排
+
+    Args:
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD)
+
+    Returns:
+        List[ExamScheduleItem]: 校统考列表
+    """
+    try:
+        timestamp = int(time.time() * 1000)
+
+        headers = {
+            **conn.client.headers,
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+
+        params = {
+            "start": start_date,
+            "end": end_date,
+            "_": str(timestamp),
+            "sf_request_type": "ajax",
+        }
+        await conn.client.get(
+            url=JWCConfig().to_full_url(ENDPOINTS["school_exam_pre_request"]),
+            follow_redirects=True,
+            headers=headers,
+            timeout=conn.timeout,
+        )
+        response = await conn.client.get(
+            url=JWCConfig().to_full_url(ENDPOINTS["school_exam_request"]),
+            headers=headers,
+            params=params,
+            follow_redirects=True,
+            timeout=conn.timeout,
+        )
+
+        if response.status_code != 200:
+            conn.logger.error(f"获取校统考信息失败: HTTP状态码 {response.status_code}")
+            return []
+        if "]" == response.text:
+            conn.logger.warning("获取校统考信息成功，但无数据")
+            return []
+        try:
+            json_data = response.json()
+        except JSONDecodeError as e:
+            conn.logger.error(f"解析校统考信息JSON失败: {str(e)}")
+            return []
+
+        # 解析为ExamScheduleItem列表
+        school_exams = []
+        if isinstance(json_data, list):
+            for item in json_data:
+                exam_item = ExamScheduleItem.model_validate(item)
+                school_exams.append(exam_item)
+
+        conn.logger.info(f"获取校统考信息成功，共 {len(school_exams)} 场考试")
+        return school_exams
+
+    except Exception as e:
+        conn.logger.error(f"获取校统考信息出现如下异常: {str(e)}")
+        return []
+
+
+async def fetch_exam_seat_info(conn: AUFEConnection) -> List[SeatInfo]:
+    """
+    获取考试座位号信息
+    conn: AUFEConnection
+
+    Returns:
+        List[SeatInfo]: 座位信息列表
+    """
+    try:
+        headers = {
+            **conn.client.headers,
+            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+        }
+
+        response = await conn.client.get(
+            url=JWCConfig().to_full_url(ENDPOINTS["seat_info"]),
+            headers=headers,
+            follow_redirects=True,
+            timeout=conn.timeout,
+        )
+
+        if response.status_code != 200:
+            conn.logger.error(
+                f"获取考试座位号信息失败: HTTP状态码 {response.status_code}"
+            )
+            return []
+        soup = BeautifulSoup(response.text, "lxml")
+        seat_infos = []
+
+        # 查找所有考试信息区块
+        exam_blocks = soup.find_all("div", {"class": "widget-box"})
+        for block in exam_blocks:
+            course_name = ""
+            seat_number = ""
+
+            # 获取课程名
+            title = block.find("h5", {"class": "widget-title"})  # type: ignore
+            if title:
+                course_text = title.get_text(strip=True)  # type: ignore
+                # 提取课程名，格式可能是: "（课程代码-班号）课程名"
+                if "）" in course_text:
+                    course_name = course_text.split("）", 1)[1].strip()
+                else:
+                    course_name = course_text.strip()
+
+            # 获取座位号
+            widget_main = block.find("div", {"class": "widget-main"})  # type: ignore
+            if widget_main:
+                content = widget_main.get_text()  # type: ignore
+                for line in content.split("\n"):
+                    if "座位号" in line:
+                        try:
+                            seat_number = line.split("座位号:")[1].strip()
+                        except Exception:
+                            try:
+                                seat_number = line.split("座位号：")[1].strip()
+                            except Exception:
+                                pass
+                        break
+
+            if course_name and seat_number:
+                seat_infos.append(
+                    SeatInfo(course_name=course_name, seat_number=seat_number)
+                )
+
+        conn.logger.info(f"获取考试座位号信息成功，共 {len(seat_infos)} 条记录")
+        return seat_infos
+
+    except Exception as e:
+        conn.logger.error(f"获取考试座位号信息异常: {str(e)}")
+        return []
+
+
+def convert_school_exam_to_unified(
+    exam: ExamScheduleItem, seat_infos: List[SeatInfo], conn: AUFEConnection
+) -> Optional[UnifiedExamInfo]:
+    """
+    将校统考数据转换为统一格式
+
+    Args:
+        exam: 校统考项目
+        seat_info: 座位号信息映射
+
+    Returns:
+        Optional[UnifiedExamInfo]: 统一格式的考试信息
+    """
+    try:
+        # 解析title信息，格式如: "新媒体导论\n08:30-10:30\n西校\n西校通慧楼\n通慧楼-308\n"
+        title_parts = exam.title.strip().split("\n")
+        if len(title_parts) < 2:
+            return None
+
+        course_name = title_parts[0]
+        exam_time = title_parts[1] if len(title_parts) > 1 else ""
+
+        # 拼接地点信息
+        location_parts = title_parts[2:] if len(title_parts) > 2 else []
+        exam_location = " ".join([part for part in location_parts if part.strip()])
+
+        # 添加座位号到备注
+        note = ""
+        for seat in seat_infos:
+            if seat.course_name == course_name:
+                note = f"座位号: {seat.seat_number}"
+                note = note.removesuffix("准考证号：")
+                break
+
+        return UnifiedExamInfo(
+            course_name=course_name,
+            exam_date=exam.start,
+            exam_time=exam_time,
+            exam_location=exam_location,
+            exam_type="校统考",
+            note=note,
+        )
+
+    except Exception as e:
+        conn.logger.error(f"转换校统考数据异常: {str(e)}")
+        return None
+
+
+async def fetch_other_exam_records(
+    term_code: str, conn: AUFEConnection
+) -> List[OtherExamRecord]:
+    """
+    获取其他考试记录
+
+    Args:
+        term_code: 学期代码
+        conn: AUFEConnection
+
+    Returns:
+        List: 其他考试记录列表
+    """
+    try:
+        headers = {
+            **conn.client.headers,
+            "Accept": "application/json, text/javascript, */*; q=0.01",
+            "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+            "X-Requested-With": "XMLHttpRequest",
+        }
+
+        data = {"zxjxjhh": term_code, "tab": "0", "pageNum": "1", "pageSize": "30"}
+
+        response = await conn.client.post(
+            url=JWCConfig().to_full_url(ENDPOINTS["other_exam_record"]),
+            headers=headers,
+            data=data,
+            follow_redirects=True,
+            timeout=conn.timeout,
+        )
+        valid = OtherExamResponse.model_validate_json(response.text)
+        if valid.records:
+            conn.logger.info(f"获取其他考试信息成功，共 {len(valid.records)} 条记录")
+            return valid.records
+        else:
+            conn.logger.warning("获取其他考试信息成功，但无记录")
+            return []
+
+    except Exception as e:
+        conn.logger.error(f"获取其他考试信息出现如下异常: {str(e)}")
+        return []
+
+
+def convert_other_exam_to_unified(
+    record: OtherExamRecord, conn: AUFEConnection
+) -> Optional[UnifiedExamInfo]:
+    """
+    将其他考试记录转换为统一格式
+
+    Args:
+        record: 其他考试记录
+
+    Returns:
+        Optional[UnifiedExamInfo]: 统一格式的考试信息
+    """
+    try:
+        return UnifiedExamInfo(
+            course_name=record.course_name,
+            exam_date=record.exam_date,
+            exam_time=record.exam_time,
+            exam_location=record.exam_location,
+            exam_type="其他考试",
+            note=record.note,
+        )
+
+    except Exception as e:
+        conn.logger.error(f"转换其他考试数据异常: {str(e)}")
+        return None
+
+
+async def fetch_unified_exam_info(
+    conn: AUFEConnection,
+    start_date: str,
+    end_date: str,
+    term_code: str = "2024-2025-2-1",
+) -> ExamInfoResponse:
+    """
+    获取统一的考试信息，包括校统考和其他考试
+
+    Args:
+        start_date: 开始日期 (YYYY-MM-DD)
+        end_date: 结束日期 (YYYY-MM-DD)
+        term_code: 学期代码，默认为当前学期
+
+    Returns:
+        ExamInfoResponse: 统一的考试信息响应
+    """
+    try:
+        # 合并并转换为统一格式
+        unified_exams = []
+        # 获取校统考信息
+        if school_exams := await fetch_school_exam_schedule(start_date, end_date, conn):
+            # 获取座位号信息
+            seat_info = await fetch_exam_seat_info(conn)
+            # 处理校统考数据
+            for exam in school_exams:
+                unified_exam = convert_school_exam_to_unified(exam, seat_info, conn)
+                if unified_exam:
+                    unified_exams.append(unified_exam)
+
+        # 获取其他考试信息
+        other_exams = await fetch_other_exam_records(term_code, conn)
+        # 处理其他考试数据
+        for record in other_exams:
+            unified_exam = convert_other_exam_to_unified(record, conn)
+            if unified_exam:
+                unified_exams.append(unified_exam)
+
+        # 按考试日期排序
+        def _sort_key(exam: UnifiedExamInfo) -> str:
+            return exam.exam_date + " " + exam.exam_time
+
+        unified_exams.sort(key=_sort_key)
+
+        return ExamInfoResponse(
+            exams=unified_exams,
+            total_count=len(unified_exams),
+        )
+
+    except Exception:
+        raise

loveace/router/endpoint/jwc/utils/plan.py

@@ -0,0 +1,67 @@
+from loveace.router.endpoint.jwc.model.plan import (
+    PlanCompletionCategory,
+    PlanCompletionCourse,
+)
+from loveace.service.remote.aufe import AUFEConnection
+
+
+def populate_category_children(
+    category: PlanCompletionCategory,
+    category_id: str,
+    nodes_by_id: dict,
+    conn: AUFEConnection,
+):
+    """填充分类的子分类和课程（支持多层嵌套）"""
+    try:
+        children_count = 0
+        subcategory_count = 0
+        course_count = 0
+
+        for node in nodes_by_id.values():
+            if node.get("pId") == category_id:
+                children_count += 1
+                flag_type = node.get("flagType", "")
+
+                if flag_type in ["001", "002"]:  # 分类或子分类
+                    subcategory = PlanCompletionCategory.from_ztree_node(node)
+                    # 递归处理子项，支持多层嵌套
+                    populate_category_children(
+                        subcategory, node["id"], nodes_by_id, conn
+                    )
+                    category.subcategories.append(subcategory)
+                    subcategory_count += 1
+                elif flag_type == "kch":  # 课程
+                    course = PlanCompletionCourse.from_ztree_node(node)
+                    category.courses.append(course)
+                    course_count += 1
+                else:
+                    # 处理其他类型的节点，也可能是分类
+                    # 根据是否有子节点来判断是分类还是课程
+                    has_children = any(
+                        n.get("pId") == node["id"] for n in nodes_by_id.values()
+                    )
+                    if has_children:
+                        # 有子节点，当作分类处理
+                        subcategory = PlanCompletionCategory.from_ztree_node(node)
+                        populate_category_children(
+                            subcategory, node["id"], nodes_by_id, conn
+                        )
+                        category.subcategories.append(subcategory)
+                        subcategory_count += 1
+                    else:
+                        # 无子节点，当作课程处理
+                        course = PlanCompletionCourse.from_ztree_node(node)
+                        category.courses.append(course)
+                        course_count += 1
+
+        if children_count > 0:
+            conn.logger.info(
+                f"分类 '{category.category_name}' (ID: {category_id}) 的子项: 总数={children_count}, 子分类={subcategory_count}, 课程={course_count}"
+            )
+
+    except Exception as e:
+        conn.logger.error(f"填充分类子项异常: {str(e)}")
+        conn.logger.error(
+            f"异常节点信息: category_id={category_id}, 错误详情: {str(e)}"
+        )
+        raise

loveace/router/endpoint/jwc/utils/zxjxjhh_to_term_format.py

@@ -0,0 +1,27 @@
+def convert_zxjxjhh_to_term_format(zxjxjhh: str) -> str:
+    """
+    转换学期格式
+    xxxx-yyyy-1-1 -> xxxx-yyyy秋季学期
+    xxxx-yyyy-2-1 -> xxxx-yyyy春季学期
+
+    Args:
+        zxjxjhh: 学期代码，如 "2025-2026-1-1"
+
+    Returns:
+        str: 转换后的学期名称，如 "2025-2026秋季学期"
+    """
+    try:
+        parts = zxjxjhh.split("-")
+        if len(parts) >= 3:
+            year_start = parts[0]
+            year_end = parts[1]
+            semester_num = parts[2]
+
+            if semester_num == "1":
+                return f"{year_start}-{year_end}秋季学期"
+            elif semester_num == "2":
+                return f"{year_start}-{year_end}春季学期"
+
+        return zxjxjhh  # 如果格式不匹配，返回原值
+    except Exception:
+        return zxjxjhh