修改请求体

api/class_api.py

@@ -43,24 +43,7 @@ def get_classes( id:int|None = None                                  # id参数
     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 )    # 返回成功响应，返回符合条件的总条数，携带符合条件的数据给前端
-    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响应，提示没有符合条件的提示给前端
-
+    return ClassResponse( code = 404,detail = '没有符合条件的班级，请检查输入是否有误')    # 判断 DAO 层的返回结果，如果为条数为0，返回404响应，提示没有符合条件的提示给前端
 
 
 
@@ -68,6 +51,6 @@ def get_class_student_count( class_id:int|None = None
 @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
+    if  r!=0 :                                     # 判断 DAO 层的返回结果，如果是True
         return ClassResponse( total=1,data='已成功删除班级信息' )  # 返回成功响应和提示给前端                                                                    # 如果是False
     raise HTTPException(status_code=500, detail='删除失败，该班级信息已不存在或服务器繁忙，请稍后更新！')  # 如果为False，抛出 500 内部服务器错误 和提示

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,delete_score_dao, exist_student_exam_dao
+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 schemas.score import ScoreCreate, ScoreUpdate, ScorePageResp
 
 scores_router = APIRouter(prefix="/scores", tags=["成绩接口"])
@@ -32,6 +32,14 @@ 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,41 +29,19 @@ 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_class_student_count_dao(class_id,class_no,class_name,page,page_size,db):       # 定义函数，设置六个形参class_id, class_no , class_name , page , page_size , db
+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 )  # 左连接学生表，并指定连接条件（未删除的学生）
@@ -82,19 +60,23 @@ def get_class_student_count_dao(class_id,class_no,class_name,page,page_size,db):
                            'class_id': i.class_id  # 提取班级ID
                          , 'class_no': i.class_no  # 提取班级编号
                          , 'class_name': i.class_name  # 提取班级名称
-                     , 'student_count':i.student_count        # 提取开课日期
+                         , '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 delete_classes_dao( class_id , db  ):    # 定义函数，设置两个个形参class_id，db
     try :                                       # 执行以下可能报错的代码
-        db.query( Classes ).filter( Classes.id == class_id , Classes.is_deleted == 0 ).update( {"is_deleted": 1} )   # 将未删除且前端输入的id和数据库id可以匹配上的数据更新is_deleted字段为1，表示已逻辑删除
+        r = db.query( Classes ).filter( Classes.id == class_id , Classes.is_deleted == 0 ).update( {"is_deleted": 1} )   # 将未删除且前端输入的id和数据库id可以匹配上的数据更新is_deleted字段为1，表示已逻辑删除
+        if r !=0:
+            db.commit()
+            return r
     except :                              # 捕获异常：
         db.rollback()                     # 如果中间出错，回滚事务，防止产生脏数据
         return False                      # 返回 False，返回接口，表示操作失败
-    else :                                # 执行成功：
-        db.commit()                       # 提交事务：更新is_deleted字段为1，表示已逻辑删除，前端无法查询到已逻辑删除的数据
-        return True                       # 返回 True，返回接口，表示操作成功

dao/score.py

@@ -5,27 +5,23 @@ 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:
-        cnt = db.query(Score).filter(
+        db.query(Score).filter(
             Score.id == score_id,
             Score.is_deleted == 0
         ).update(updates)
-        if cnt == 0:
-            db.rollback()
-            return False
-    except Exception as e:
-        print("修改成绩异常：", e)
+    except Exception:
         db.rollback()
         return False
     else:
@@ -34,19 +30,8 @@ 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 == 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:
@@ -73,20 +58,36 @@ 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:
-        cnt = db.query(Score).filter(
+        db.query(Score).filter(
             Score.id == score_id,
             Score.is_deleted == 0
-        ).update({"is_deleted": 1})     # ← 接住返回值
-        if cnt == 0:                    # ← 关键：一行都没匹配到
-            db.rollback()
-            return False
+        ).update({"is_deleted": 1})
     except Exception as err:
         print("删除成绩异常：", err)
         db.rollback()

models/class_model.py

@@ -25,8 +25,12 @@ class Classes( Base ):              # 在python里的名字
     start_date = Column( DATE             # 声明是字段数据类型是日期
                        , nullable = False  # 开课时间必填
                        )
-    # ————创建班级"结课时间"的字段名————
-    end_date = Column( DATE               # 声明是字段数据类型是'日期'
+    # ————创建班级"计划结课时间"的字段名————
+    pland_end_date = Column( DATE               # 声明是字段数据类型是'日期'
+                     , nullable = True     # 声明是"可为空"
+                     )
+    # ————创建班级"实际结课时间"的字段名————
+    true_end_date = Column( DATE               # 声明是字段数据类型是'日期'
                      , nullable = True     # 声明是"可为空"
                      )
     # ————创建班级"创建时间"的字段名————

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|None = None       # 班级开课日期"，可以为空，默认为空
-    end_date : date|None = None         # 班级结课日期"，可以为空，默认为空
-    remark : str|None = None            # 班级备注"，可以为空，默认为空
+    class_no: str                       # 班级编号，不可为空
+    class_name: str                     # 班级名字，不可为空
+    start_date : date                   # 班级开课日期，不可为空
+    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 = ''        # 返回的数据,默认为空字符串