已优化get方法以及修改delete删除过后还显示删除成功的问题

api/class_api.py

@@ -12,45 +12,62 @@ classes_router = APIRouter()
 
 # ————定义班级表"新增"信息的接口函数————
 @classes_router.post('/',response_model=ClassResponse,summary='新增班级信息')        # POST新增请求，指定返回数据格式为 ClassResponse
-def post_classes(classes:ClassCreate,db=Depends(get_db)):  # 定义更新接口函数，参数classes声明创建请求模型，参数db依赖于数据库会话的上下文管理器
-    c = classes.model_dump()                     # 变量c用来接收通过model_dump将Pydantic模型对象解析为Python的字典，方便后续解包传参
-    r = post_classes_dao( c , db )               # 变量r用来接收dao层post_classes_dao函数的返回值，执行函数时以变量c的数据和db依赖函数入参
-    if r :                                       # 判断 DAO 层的返回结果，如果为True
-        return ClassResponse( total=1,data=c )   # 返回成功响应，携带新增的数据给前端
-    else :                                       # 如果为False
+def post_classes(classes:ClassCreate,db=Depends(get_db)):          # 定义更新接口函数，参数classes声明创建请求模型，参数db依赖于数据库会话的上下文管理器
+    c = classes.model_dump()                                       # 变量c用来接收通过model_dump将Pydantic模型对象解析为Python的字典，方便后续解包传参
+    r = post_classes_dao( c , db )                                 # 变量r用来接收dao层post_classes_dao函数的返回值，执行函数时以变量c的数据和db依赖函数入参
+    if r :                                                         # 判断 DAO 层的返回结果，如果为True
+        return ClassResponse( total=1,data=c )                     # 返回成功响应，携带新增的数据给前端
+    else :                                                         # 如果为False
         raise HTTPException(status_code=500,detail='添加失败，服务器繁忙，请稍后添加！') # 抛出 500 内部服务器错误 和提示
 
 
 # ————定义班级表"更新"信息的接口函数————
 @classes_router.put('/{id}',response_model=ClassResponse,summary='更新班级信息')    # put更新请求，指定返回数据格式为 ClassResponse
 def put_classes( classes:ClassUpdate , id:int , db=Depends( get_db ) ):                # 定义更新接口函数，id参数接收前端输入的数据，参数classes声明更新请求体模型，参数db依赖于数据库会话的上下文管理器
-    updates = classes.model_dump( exclude_unset=True )         # 变量updates用来接收通过model_dump将Pydantic模型对象解析为Python的字典(只解析输入的数据)，方便后续解包传参
-    r = update_classes_dao( id, db, updates )                  # 变量r用来接收dao层update_classes_dao函数的返回值，执行函数时以变量c的数据、db依赖函数、和前端更新的数据入参
-    if r :                                                     # 判断 DAO 层的返回结果，如果为True
+    updates = classes.model_dump( exclude_unset=True )               # 变量updates用来接收通过model_dump将Pydantic模型对象解析为Python的字典(只解析输入的数据)，方便后续解包传参
+    r = update_classes_dao( id, db, updates )                        # 变量r用来接收dao层update_classes_dao函数的返回值，执行函数时以变量c的数据、db依赖函数、和前端更新的数据入参
+    if r :                                                           # 判断 DAO 层的返回结果，如果为True
         return ClassResponse( detail='更新成功', total=1 ,data = updates )    # 返回成功响应，携带更新的数据给前端
     raise HTTPException( status_code=500, detail='更新失败，该班级已不存在或服务器繁忙，请稍后更新！' )  # 如果为False，抛出 500 内部服务器错误 和提示
 
 
 # ————定义班级表"查询"信息的接口函数————
-@classes_router.get('',summary='查询班级信息')      # get查询请求
-def get_classes( id:int|None = None                    # id参数接收前端输入的数据，声明是整数，可以为空默认为空
-               , class_no:str|None = None              # class_no参数接收前端输入的数据，声明是字符串，可以为空默认为空
-               , class_name:str|None = None            # class_name参数接收前端输入的数据，声明是字符串，可以为空默认为空
-               , page:int = 1                          # page参数接收前端输入的数据，声明是整数，默认是1
-               , page_size:int = 5                     # page参数接收前端输入的数据，声明是整数，默认是5
-               , db=Depends(get_db)                    # 参数db依赖于数据库会话的上下文管理器
+@classes_router.get('',summary='查询班级信息')                    # get查询请求
+def get_classes( id:int|None = None                                  # id参数接收前端输入的数据，声明是整数，可以为空默认为空
+               , class_no:str|None = None                            # class_no参数接收前端输入的数据，声明是字符串，可以为空默认为空
+               , class_name:str|None = None                          # class_name参数接收前端输入的数据，声明是字符串，可以为空默认为空
+               , page:int = 1                                        # page参数接收前端输入的数据，声明是整数，默认是1
+               , page_size:int = 5                                   # page参数接收前端输入的数据，声明是整数，默认是5
+               , db=Depends(get_db)                                  # 参数db依赖于数据库会话的上下文管理器
                ):
     t,r = get_classes_dao( id , class_no , class_name , page , page_size ,db )  # 变量t,r用来接收dao层get_classes_dao函数的返回值，执行函数时以前端输入的id , class_no , class_name , page , page_size 、db依赖函数入参
-    if t != 0 :                                        # 判断 DAO 层的返回结果，如果为条数不为0
-        return ClassResponse( total = t, data = r )    # 返回成功响应，返回符合条件的总条数，携带符合条件的数据给前端
-    return ClassResponse( code = 404,detail = '没有符合条件的班级，请检查输入是否有误')    # 判断 DAO 层的返回结果，如果为条数为0，返回404响应，提示没有符合条件的提示给前端
+    if t != 0 :                                                # 判断 DAO 层的返回结果，如果为条数不为0
+        return ClassResponse( total = t, data = r )            # 返回成功响应，返回符合条件的总条数，携带符合条件的数据给前端
+    else :                                                     # 判断 DAO 层的返回结果，如果为条数为0
+        return ClassResponse( code = 404,detail = '没有符合条件的班级，请检查输入是否有误')    # 返回404响应，提示没有符合条件的提示给前端
+
+
+# ————定定义查询符合查询条件的班级的总学生人数信息的接口函数————
+@classes_router.get('/student-count', summary='查询每个班级学生人数')           # get查询请求
+def get_class_student_count( class_id:int|None = None                            # id参数接收前端输入的数据，声明是整数，可以为空默认为空
+                           , class_no:str|None = None                            # class_no参数接收前端输入的数据，声明是字符串，可以为空默认为空
+                           , class_name:str|None = None                          # class_name参数接收前端输入的数据，声明是字符串，可以为空默认为空
+                           , page:int = 1                                        # page参数接收前端输入的数据，声明是整数，默认是1
+                           , page_size:int = 5                                   # page参数接收前端输入的数据，声明是整数，默认是5
+                           , db=Depends(get_db)                                  # 参数db依赖于数据库会话的上下文管理器
+                           ):
+    t,r = get_class_student_count_dao(class_id,class_no,class_name,page,page_size,db)   # 变量t,r用来接收dao层get_classes_dao函数的返回值，执行函数时以前端输入的id , class_no , class_name , page , page_size 、db依赖函数入参
+    if r:                                                  # 判断 DAO 层的返回结果，如果为True
+        return ClassResponse(total=t, data=r)              # 返回成功响应，携带符合条件的数据给前端
+    return ClassResponse(code=404, detail='没有班级数据')    # 如果 DAO 层返回的结果为False，返回404响应，提示没有符合条件的提示给前端
+
 
 
 
 # ————定义班级表"删除"信息的接口函数————
 @classes_router.delete('/{id}',response_model=ClassResponse,summary='删除班级信息')   # delete删除请求，指定返回数据格式为 ClassResponse
-def delete_classes(id:int,db=Depends(get_db)):  # 定义删除接口函数，id参数接收前端输入的数据，参数db依赖于数据库会话的上下文管理器
-    r = delete_classes_dao( id , db )           # 变量r用来接收dao层delete_classes_dao函数的返回值，执行函数时以以前端输入的id 数据、db依赖函数入参
-    if  r :                                     # 判断 DAO 层的返回结果，如果是True
-        return ClassResponse( total=1,data='已成功删除班级信息' )  # 返回成功响应和提示给前端                                                                    # 如果是False
+def delete_classes(id:int,db=Depends(get_db)):                                           # 定义删除接口函数，id参数接收前端输入的数据，参数db依赖于数据库会话的上下文管理器
+    r = delete_classes_dao( id , db )                                                    # 变量r用来接收dao层delete_classes_dao函数的返回值，执行函数时以以前端输入的id 数据、db依赖函数入参
+    if  r :                                                                              # 判断 DAO 层的返回结果，如果是True
+        return ClassResponse( total=1,data='已成功删除班级信息' )                            # 返回成功响应和提示给前端                                                                    # 如果是False
     raise HTTPException(status_code=500, detail='删除失败，该班级信息已不存在或服务器繁忙，请稍后更新！')  # 如果为False，抛出 500 内部服务器错误 和提示

api/employment.py

@@ -12,7 +12,7 @@ from schemas.employment import (EmploymentCreate,
                                 EmploymentUpdate,
                                 EmploymentResponse)
 
-employment_router = APIRouter( tags=["就业管理模块"])
+employment_router = APIRouter(prefix="/employments", tags=["就业管理模块"])
 
 
 @employment_router.post("/", response_model=EmploymentResponse, summary="新增就业信息")
@@ -38,12 +38,14 @@ def query_student_employment(student_id: int, db: Session = Depends(get_db)):
 
 
 @employment_router.get("/", summary="就业信息列表，支持筛选")
-def query_employment_list(company_name: str | None = Query(None, description="公司名称模糊查询"),
-                          salary_min: float | None = Query(None, description="最低薪资"),
-                          salary_max: float | None = Query(None, description="最高薪资"),
-                          skip: int = Query(0, ge=0, description="偏移量"),
-                          limit: int = Query(20, ge=1, le=100, description="每页条数"),
-                          db: Session = Depends(get_db)):
+def query_employment_list(
+    company_name: str | None = Query(None, description="公司名称模糊查询"),
+    salary_min: float | None = Query(None, description="最低薪资"),
+    salary_max: float | None = Query(None, description="最高薪资"),
+    skip: int = Query(0, ge=0, description="偏移量"),
+    limit: int = Query(20, ge=1, le=100, description="每页条数"),
+    db: Session = Depends(get_db)
+):
     # 调用dao列表查询，拿到数据字典列表和总条数
     data_list, total = get_employment_list(db, company_name, salary_min, salary_max, skip, limit)
     return {"total": total, "data": data_list}

api/score.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 from core.database import get_db
-from dao.score import post_score_dao, update_score_dao, get_score_dao, get_all_scores_dao,delete_score_dao, exist_student_exam_dao
+from dao.score import post_score_dao, update_score_dao, get_score_dao,delete_score_dao, exist_student_exam_dao
 from schemas.score import ScoreCreate, ScoreUpdate, ScorePageResp
 
 scores_router = APIRouter(prefix="/scores", tags=["成绩接口"])
@@ -32,14 +32,6 @@ def list_score(
 
 
 
-@scores_router.get("/all", response_model=ScorePageResp,
-                   summary="所有学生成绩接口",
-                  )
-def list_all_scores(page: int = Query(1, ge=1),
-                    page_size: int = Query(10, ge=1, le=100),
-                    db: Session = Depends(get_db)):
-    total, data_list = get_all_scores_dao(page, page_size, db)
-    return {"total": total, "data": data_list}
 
 @scores_router.put("{score_id}", summary="更新成绩接口")
 def modify_score(score_id: int, req: ScoreUpdate, db: Session = Depends(get_db)):

dao/class_dao.py

@@ -29,46 +29,64 @@ def update_classes_dao( class_id , db , updates ):     # 定义函数，设置
 
 
 # ————定义班级表"查询"信息的函数————
+def get_classes_dao( class_id, class_no , class_name , page , page_size , db ):   # 定义函数，设置六个形参class_id, class_no , class_name , page , page_size , db
+    q = db.query( Classes ).filter( Classes.is_deleted == 0 )                     # 初始化查询语句，基础过滤条件为筛选未删除的数据 (is_deleted=0)
+    if class_id :                                                                 # 如果传入了班级id参数
+        q = q.filter( Classes.id == class_id )                                    # 则追加id过滤条件
+    if class_no :                                                                 # 如果传入了班级no参数
+        q = q.filter( Classes.class_no == class_no )                              # 则追加no过滤条件
+    if class_name :                                                               # 如果传入了班级name参数
+        q = q.filter( Classes.class_name == class_name )                          # 则追加name过滤条件
+    total = q.count()                                                             # total变量接收满足当前所有过滤条件的数据总条数
+    r = q.offset( ( page-1 ) * page_size  ).limit( page_size ).all()              # 变量r用来接收查询取出结果列表，计算分页偏移量（从第几行开始查），设置分页限制条数
+    return total , [                                                              # 返回 total变量总条数 和 将查询结果列表转换为字典列表的数据
+                     {
+                         'class_id':i.id                  # 提取班级ID
+                       , 'class_no':i.class_no            # 提取班级编号
+                       , 'class_name':i.class_name        # 提取班级名称
+                       , 'start_date':i.start_date        # 提取开课日期
+                       , 'end_date':i.end_date            # 提取结课日期
+                       , 'created_at':i.created_at        # 提取创建时间
+                       , 'update_at':i.update_at          # 提取更新时间
+                       , 'remark':i.remark                # 提取备注信息
+                      }
+                      for i in r                          # 循环遍历查询出的每一行数据 i
+                    ]
+
+
+
+# ————定义查询符合查询条件的班级的总学生人数信息的函数————
 from sqlalchemy import func, and_ ,desc             # 从sqlalchemy模块导入func聚合函数的类、and_函数，降序排序desc函数
 from models.student import Student                  # 从models包下的student模块导入Student表模型类
 
-def get_classes_dao( class_id, class_no , class_name , page , page_size , db ):   # 定义函数，设置六个形参class_id, class_no , class_name , page , page_size , db
-    q = db.query(  Classes.id.label('class_id')  # 查询班级ID(别名class_id)
-                 , Classes.class_no  # 班级编号
-                 , Classes.class_name  # 班级名称
-                 , func.count(Student.id).label('student_count')  # 统计班级未删除的学生人数(别名student_count)
-                 , Classes.start_date   #开课时间
-                 , Classes.end_date    #结课时间
-                 , Classes.created_at   #创建时间
-                 , Classes.update_at    #更新时间
-                 , Classes.remark       #备注信息
-                 ). \
-                 outerjoin(Student, and_(Classes.id == Student.class_id, Student.is_deleted == 0)). \
-                 filter( Classes.is_deleted == 0 )  # 左连接学生表，并指定连接条件（未删除的学生）
-    if class_id :                                                        # 如果传入了班级id参数
-        q = q.filter( Classes.id == class_id )                           # 则追加id过滤条件
-    if class_no :                                                        # 如果传入了班级no参数
-        q = q.filter( Classes.class_no == class_no )                     # 则追加no过滤条件
-    if class_name :                                                      # 如果传入了班级name参数
-        q = q.filter( Classes.class_name == class_name )                 # 则追加name过滤条件
-    q = q.group_by(Classes.id, Classes.class_no, Classes.class_name)  # 按班级ID、编号、名称进行分组聚合
-    q = q.order_by( desc('student_count') )  # 按学生人数（别名）进行降序排列
-    total = q.count()  # total变量接收满足当前所有过滤条件的数据总条数
-    r = q.offset((page - 1) * page_size).limit(page_size).all()  # 变量r用来接收查询取出结果列表，计算分页偏移量（从第几行开始查），设置分页限制条数
-    return total, [  # 返回 total变量总条数 和 将查询结果列表转换为字典列表的数据
-                     {
-                           'class_id': i.class_id  # 提取班级ID
-                         , 'class_no': i.class_no  # 提取班级编号
-                         , 'class_name': i.class_name  # 提取班级名称
-                         , 'student_count': i.student_count  # 提取班级总人数
-                         , 'start_date':i.start_date        # 提取开课日期
-                         , 'end_date':i.end_date            # 提取结课日期
-                         , 'created_at':i.created_at        # 提取创建时间
-                         , 'update_at':i.update_at          # 提取更新时间
-                         , 'remark':i.remark                # 提取备注信息
-                     }
-                        for i in r  # 循环遍历查询出的每一行数据 i
-                  ]
+def get_class_student_count_dao(class_id,class_no,class_name,page,page_size,db):       # 定义函数，设置六个形参class_id, class_no , class_name , page , page_size , db
+    q = db.query (  Classes.id.label('class_id')                  # 查询班级ID(别名class_id)
+                  , Classes.class_no                              # 班级编号
+                  , Classes.class_name                            # 班级名称
+                  , func.count(Student.id).label('student_count') # 统计班级未删除的学生人数(别名student_count)
+                  ) .\
+                  outerjoin(  Student, and_(Classes.id == Student.class_id,Student.is_deleted == 0)).\
+                  filter(Classes.is_deleted == 0)    # 左连接学生表，并指定连接条件（未删除的学生）
+    if class_id :                                                       # 如果传入了班级id参数
+        q = q.filter( Classes.id == class_id )                          # 则追加id过滤条件
+    if class_no :                                                       # 如果传入了班级no参数
+        q = q.filter( Classes.class_no == class_no )                    # 则追加no过滤条件
+    if class_name :                                                     # 如果传入了班级name参数
+        q = q.filter( Classes.class_name == class_name )                # 则追加name过滤条件
+    q = q.group_by(Classes.id, Classes.class_no, Classes.class_name)    # 按班级ID、编号、名称进行分组聚合
+    q = q.order_by(  desc('student_count') )                            # 按学生人数（别名）进行降序排列
+    total = q.count()                                     # total变量接收满足当前所有过滤条件的数据总条数
+    r = q.offset( ( page-1 ) * page_size  ).limit( page_size ).all()    # 变量r用来接收查询取出结果列表，计算分页偏移量（从第几行开始查），设置分页限制条数
+    return total,[                                          # 返回 total变量总条数 和 将查询结果列表转换为字典列表的数据
+                   {
+                       'class_id':i.class_id                  # 提取班级ID
+                     , 'class_no':i.class_no                  # 提取班级编号
+                     , 'class_name':i.class_name              # 提取班级名称
+                     , 'student_count':i.student_count        # 提取开课日期
+                    }
+                       for i in r                             # 循环遍历查询出的每一行数据 i
+                 ]
+
 
 # ————定义班级表"删除"信息的函数————
 def delete_classes_dao( class_id , db  ):    # 定义函数，设置两个个形参class_id，db

dao/employment.py

@@ -4,26 +4,14 @@ from schemas.employment import EmploymentCreate, EmploymentUpdate, EmploymentRes
 
 
 def create_employment(db, obj_in):
-    # obj_in是Pydantic对象(EmploymentCreate)
     """新增就业信息：一个学生只能存在一条就业记录"""
     try:
         db_obj = Employment(**obj_in.model_dump())
-        db.add(db_obj)
-        db.commit()
-        db.refresh(db_obj)
-
-        resp = EmploymentResponse(id=db_obj.id
-                                  ,student_id=db_obj.student_id
-                                  ,employment_status=db_obj.employment_status
-                                  ,employment_open_date=db_obj.employment_open_date
-                                  ,offer_date=db_obj.offer_date
-                                  ,company_name=db_obj.company_name
-                                  ,salary=db_obj.salary
-                                  ,remark=db_obj.remark
-                                  ,created_at=db_obj.created_at
-                                  ,updated_at=db_obj.updated_at)
-        return resp.model_dump()
-
+        db.add(db_obj)                      # add：把对象加入数据库会话，此时还没写入数据库
+        db.commit()                         # commit：提交事务，真正写入mysql数据库
+        db.refresh(db_obj)                  # refresh：从数据库刷新对象，拿到数据库自动生成的id、默认时间等字段
+        return EmploymentResponse.model_validate(db_obj).model_dump()
+        # model_validate：把sqlalchemy ORM对象解析进pydantic响应模型
     except Exception:
         db.rollback()
         return None
@@ -36,18 +24,7 @@ def get_employment_by_id(db, eid):
                                              ,Employment.is_deleted == 0).first()
         if not db_obj:
             return None
-
-        resp = EmploymentResponse(id=db_obj.id
-                                  ,student_id=db_obj.student_id
-                                  ,employment_status=db_obj.employment_status
-                                  ,employment_open_date=db_obj.employment_open_date
-                                  ,offer_date=db_obj.offer_date
-                                  ,company_name=db_obj.company_name
-                                  ,salary=db_obj.salary
-                                  ,remark=db_obj.remark
-                                  ,created_at=db_obj.created_at
-                                  ,updated_at=db_obj.updated_at)
-        return resp.model_dump()
+        return EmploymentResponse.model_validate(db_obj).model_dump()
     except Exception:
         return None
 
@@ -59,18 +36,7 @@ def get_employment_by_student_id(db, student_id):
                                              ,Employment.is_deleted == 0).first()
         if not db_obj:
             return None
-
-        resp = EmploymentResponse(id=db_obj.id
-                                  ,student_id=db_obj.student_id
-                                  ,employment_status=db_obj.employment_status
-                                  ,employment_open_date=db_obj.employment_open_date
-                                  ,offer_date=db_obj.offer_date
-                                  ,company_name=db_obj.company_name
-                                  ,salary=db_obj.salary
-                                  ,remark=db_obj.remark
-                                  ,created_at=db_obj.created_at
-                                  ,updated_at=db_obj.updated_at)
-        return resp.model_dump()
+        return EmploymentResponse.model_validate(db_obj).model_dump()
     except Exception:
         return None
 
@@ -85,26 +51,16 @@ def get_employment_list(db, company_name=None, salary_min=None, salary_max=None,
             query = query.filter(Employment.salary >= salary_min)
         if salary_max is not None:
             query = query.filter(Employment.salary <= salary_max)
-
+        # count()统计满足条件总条数，用于分页total
         total = query.count()
+        # offset偏移量（跳过多少条），limit每页多少条，执行查询拿到结果列表
         records = query.offset(skip).limit(limit).all()
-
-        dict_list = []
-        for item in records:
-            resp = EmploymentResponse(id=item.id
-                                      ,student_id=item.student_id
-                                      ,employment_status=item.employment_status
-                                      ,employment_open_date=item.employment_open_date
-                                      ,offer_date=item.offer_date
-                                      ,company_name=item.company_name
-                                      ,salary=item.salary
-                                      ,remark=item.remark
-                                      ,created_at=item.created_at
-                                      ,updated_at=item.updated_at)
-            dict_list.append(resp.model_dump())
-
+        # 列表推导式：循环每一条ORM记录，全部转为字典，得到字典列表
+        dict_list = [EmploymentResponse.model_validate(item).model_dump() for item in records]
+        # 返回字典列表 + 总条数
         return dict_list, total
     except Exception:
+        # 异常返回空列表，总条数0
         return [], 0
 
 
@@ -112,29 +68,15 @@ def update_employment(db, eid, obj_in):
     """修改就业信息，只更新传入的字段"""
     try:
         db_obj_raw = db.query(Employment).filter(Employment.id == eid
-                                                 ,Employment.is_deleted == 0).first()
+                                                ,Employment.is_deleted == 0).first()
         if db_obj_raw is None:
             return None
-
-        update_dict = obj_in.model_dump(exclude_unset=True)
-        db.query(Employment).filter(Employment.id == eid
-                                    ,Employment.is_deleted == 0).update(update_dict)
-
+        update_dict = obj_in.model_dump(exclude_unset=True)# exclude_unset=True：只取出前端实际传过来的字段，不会带上没传的None字段
+        for key, value in update_dict.items():
+            setattr(db_obj_raw, key, value)
         db.commit()
         db.refresh(db_obj_raw)
-
-        resp = EmploymentResponse(id=db_obj_raw.id
-                                  ,student_id=db_obj_raw.student_id
-                                  ,employment_status=db_obj_raw.employment_status
-                                  ,employment_open_date=db_obj_raw.employment_open_date
-                                  ,offer_date=db_obj_raw.offer_date
-                                  ,company_name=db_obj_raw.company_name
-                                  ,salary=db_obj_raw.salary
-                                  ,remark=db_obj_raw.remark
-                                  ,created_at=db_obj_raw.created_at
-                                  ,updated_at=db_obj_raw.updated_at)
-        return resp.model_dump()
-
+        return EmploymentResponse.model_validate(db_obj_raw).model_dump()
     except Exception:
         db.rollback()
         return None

dao/score.py

@@ -5,23 +5,27 @@ def post_score_dao(data_dict, db):
     try:
         obj = Score(**data_dict)
         db.add(obj)
+        db.commit()
     except Exception as e:
         print("新增成绩异常：", e)
         db.rollback()
         return False
     else:
-        db.commit()
         return True
 
 
 def update_score_dao(score_id, db, updates):
     """修改成绩，query.update方式"""
     try:
-        db.query(Score).filter(
+        cnt = db.query(Score).filter(
             Score.id == score_id,
             Score.is_deleted == 0
         ).update(updates)
-    except Exception:
+        if cnt == 0:
+            db.rollback()
+            return False
+    except Exception as e:
+        print("修改成绩异常：", e)
         db.rollback()
         return False
     else:
@@ -30,14 +34,25 @@ def update_score_dao(score_id, db, updates):
 
 
 def get_score_dao(score_id, student_id, exam_seq, page, page_size, db):
-    """分页查询成绩，多条件过滤，只查未删除"""
+    """分页查询成绩，多条件过滤，只查未删除
+    规则：
+      - score_id == 0                → 查所有学生成绩（仅分页，不加 id 过滤）
+      - 三个筛选条件全为空（None）   → 直接返回空，不查库
+      - 其他情况                     → 按传入条件过滤
+    """
     q = db.query(Score).filter(Score.is_deleted == 0)
-    if score_id:
-        q = q.filter(Score.id == score_id)
-    if student_id:
-        q = q.filter(Score.student_id == student_id)
-    if exam_seq:
-        q = q.filter(Score.exam_seq == exam_seq)
+
+    if score_id == 0:
+        pass                                  # score_id=0 → 查全部（分页）
+    elif score_id is None and not student_id and not exam_seq:
+        return 0, []                          # 三个参数都没传 → 返回空
+    else:
+        if score_id:
+            q = q.filter(Score.id == score_id)
+        if student_id:
+            q = q.filter(Score.student_id == student_id)
+        if exam_seq:
+            q = q.filter(Score.exam_seq == exam_seq)
 
     total = q.count()
     rows = q.offset((page - 1) * page_size).limit(page_size).all()
@@ -58,36 +73,20 @@ def get_score_dao(score_id, student_id, exam_seq, page, page_size, db):
     ]
     return total, res_list
 
-def get_all_scores_dao(page, page_size, db):
-    r = db.query(Score).filter(Score.is_deleted == 0)\
-           .order_by(Score.student_id, Score.exam_seq)
-    total = r.count()                                    # 总条数
-    rows = r.offset((page-1)*page_size).limit(page_size).all()# 分页
-    res_list_all = [
-        {
-            "id": i.id,
-            "student_id": i.student_id,
-            "score": i.score,
-            "exam_seq": i.exam_seq,
-            "exam_date": i.exam_date,
-            "remark": i.remark,
-            "created_at": i.created_at,
-            "updated_at": i.updated_at,
-            "is_deleted": i.is_deleted
-        }
-        for i in rows
-    ]
-    return total,res_list_all
+
+
 
 
 
 def delete_score_dao(score_id, db):
-    """逻辑删除，更新is_deleted=1"""
     try:
-        db.query(Score).filter(
+        cnt = db.query(Score).filter(
             Score.id == score_id,
             Score.is_deleted == 0
-        ).update({"is_deleted": 1})
+        ).update({"is_deleted": 1})     # ← 接住返回值
+        if cnt == 0:                    # ← 关键：一行都没匹配到
+            db.rollback()
+            return False
     except Exception as err:
         print("删除成绩异常：", err)
         db.rollback()

dao/statistics.py

@@ -1,6 +1,6 @@
 from schemas.statistics import NoExist
 from sqlalchemy import func
-
+from time import time
 #`GET /statistics/students/age-over-30`
 #查询所有超过 30 岁的学员信息
 

magic_llm/llm_func.py

@@ -16,7 +16,7 @@ def llm_func(input_user):
     base_url="https://api.deepseek.com"
     )
 
-    prom_path = Path(__file__).parent / "prom.txt"   #拼接路径
+    prom_path = Path(__file__).parent / "prom.txt"
     context = prom_path.read_text(encoding="utf-8")
 
 

main.py

@@ -7,7 +7,7 @@ from api.student import student_router
 from api.teacher import router as teacher_router,class_teacher_router
 from api.magic import magic_router
 
-app = FastAPI(title='学生管理系统')
+app = FastAPI()
 app.middleware("http")(log_middleware)
 app.include_router(magic_router)
 

models/employment.py

@@ -1,17 +1,17 @@
-from sqlalchemy import *               #导入sqlalchemy全部常用类
-from sqlalchemy.orm import declarative_base,sessionmaker  #造会话工厂 SessionLocal，管数据库增删改查会话
+from sqlalchemy import *
+from sqlalchemy.orm import declarative_base,sessionmaker
 from datetime import datetime
-from core.database import Base         #保证所有模型共用同一个Base，表才能正常生成
+from core.database import Base
 
 # 为了符合三范式，就业表只保存 student_id，不保存学生姓名和班级名称。查询返回时通过关联 students 和 classes 带出学生姓名、班级名称。
 
 class Employment(Base):
-    __tablename__ = "employment_info_detail"                   # 映射的真实MySQL数据库表名
+    __tablename__ = "employment_info_detail"                   # 实际数据库的表名字
     id = Column(Integer, primary_key=True                      # 主键
-                , autoincrement=True                           # 开启自增，插入数据不需要手动传id，数据库自动生成id
+                , autoincrement=True                           # 声明是自增主键
                 ,comment="就业信息主键id")
     student_id = Column(Integer, ForeignKey("student_info_detail.id")  # 外键 -> students.id
-                        , nullable=False                       # 不允许为null，每一条就业记录必须绑定一个学生
+                        , nullable=False                       # 不允许为null
                         ,comment="关联学生id")
     employment_status = Column(String(50)
                                , default="not_started"

schemas/class_schema.py

@@ -6,11 +6,11 @@ from datetime import datetime,date       # 导入datetime模块下的datetime,da
 
 # ————定义"创建班级"的"请求体"模型————
 class ClassCreate( BaseModel ):         # "创建"班级信息的请求体模型
-    class_no: str                       # 班级编号，不可为空
-    class_name: str                     # 班级名字，不可为空
-    start_date : date                   # 班级开课日期，不可为空
-    end_date : date|None = None         # 班级结课日期，可以为空，默认为空
-    remark : str|None = None            # 班级备注，可以为空，默认为空
+    class_no: str                       # 班级编号"，不可为空
+    class_name: str                     # 班级名字"，不可为空
+    start_date : date|None = None       # 班级开课日期"，可以为空，默认为空
+    end_date : date|None = None         # 班级结课日期"，可以为空，默认为空
+    remark : str|None = None            # 班级备注"，可以为空，默认为空
 
 # ————定义"更新班级"的"请求体"模型————
 class ClassUpdate( BaseModel ):          # "更新"班级信息的请求体模型
@@ -25,4 +25,4 @@ class ClassResponse( BaseModel ):        # 班级信息的响应体模型
     code:int = 200                       # 状态码，默认200
     detail:str = '执行成功'                # 提示信息
     total:int = 0                        # 数据总条数，默认为0
-    data:str|dict|list|tuple = ''        # 返回的数据,默认为空字符串
+    data:str|dict|list|tuple = ''            # 返回的数据

schemas/employment.py

@@ -1,12 +1,12 @@
-from pydantic import BaseModel, Field,ConfigDict#专门存放模型配置参数的字典类。把各种开关配置放里面。
+from pydantic import BaseModel, Field,ConfigDict
 from datetime import date, datetime
 from decimal import Decimal
 
 
 class EmploymentCreate(BaseModel):
     """新增就业信息 请求体 Schema"""
-    student_id: int = Field(..., description="关联学生ID，必填")# description：在Swagger页面展示字段说明文字
-    employment_status: str | None = Field(None, description="就业状态,选填")
+    student_id: int = Field(..., description="关联学生ID，必填")
+    employment_status: str | None = Field(None, description="就业状态：not_started/job_hunting/offered/employed")
     employment_open_date: date | None = Field(None, description="就业开放时间，选填")
     offer_date: date | None = Field(None, description="offer下发时间，选填")
     company_name: str | None = Field(None, max_length=100, description="就业公司名称，选填")
@@ -36,3 +36,4 @@ class EmploymentResponse(BaseModel):
     remark: str | None
     created_at: datetime | None
     updated_at: datetime | None
+    model_config = ConfigDict(from_attributes=True) #允许pydantic从对象属性里取值