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

Reviewed-on: #43

api/class_api.py

@@ -46,6 +46,24 @@ def get_classes( id:int|None = None                                  # id参数
     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依赖于数据库会话的上下文管理器

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,delete_score_dao, exist_student_exam_dao
 from schemas.score import ScoreCreate, ScoreUpdate, ScorePageResp
 
 scores_router = APIRouter(prefix="/scores", tags=["成绩接口"])
@@ -12,14 +12,13 @@ def create_score(req: ScoreCreate, db: Session = Depends(get_db)):
     # 业务校验：联合唯一
     if exist_student_exam_dao(req.student_id, req.exam_seq, db):
         raise HTTPException(status_code=400, detail="该学生本次考试成绩已存在，不能重复录入")
-
     ok = post_score_dao(req.model_dump(), db)
     if not ok:
         raise HTTPException(status_code=400, detail="新增成绩失败，请检查学生id是否存在")
     return {"msg": "新增成功"}
 
 
-@scores_router.get("", response_model=ScorePageResp, summary="查询成绩接口")
+@scores_router.get("", response_model=ScorePageResp, summary="个人成绩查询接口")
 def list_score(
     score_id: int|None=None,
     student_id: int |None=None,
@@ -32,6 +31,8 @@ def list_score(
     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)):
     update_dict = req.model_dump(exclude_unset=True)

api/student.py

@@ -1,4 +1,5 @@
-from fastapi import APIRouter, Depends, HTTPException
+
+from fastapi import APIRouter, Depends, HTTPException,Query,Path
 from sqlalchemy.orm import Session
 
 from core.database import get_db
@@ -6,7 +7,7 @@ from schemas.student import StudentCreate, StudentUpdate
 from dao import student as student_dao
 student_router = APIRouter()
 
-@student_router.post("",summary='添加学生')
+@student_router.put("",summary='添加学生')
 def create_student(request:StudentCreate,db:Session = Depends(get_db)):
     d = request.model_dump()
     r = student_dao.create_students(d,db)
@@ -14,7 +15,7 @@ def create_student(request:StudentCreate,db:Session = Depends(get_db)):
         raise HTTPException(status_code=500,detail='服务器繁忙，请稍后添加！')
     return {'code':200,'detail':"添加学生成功"}
 
-@student_router.put("/{id}", summary="修改学生")
+@student_router.post("/{id}", summary="更新学生信息")
 def update_student(
     id: int,
     request: StudentUpdate,
@@ -34,38 +35,69 @@ def update_student(
     if student is False:
         raise HTTPException(status_code=500, detail="修改学生失败")
 
+    #传入空字典报400
+    if not data:
+        raise HTTPException(
+            status_code=400,
+            detail="没有传入需要修改的字段",
+        )
+
     return {
         "code": 200,
         "detail": "修改学生成功",
         "data": student,
     }
 
-@student_router.get("", summary="查询学生列表")
+@student_router.get("", summary="分页查询学生列表")
 def get_students(
     # 三个查询条件都可以不传
-    student_no: str | None = None,
-    student_name: str | None = None,
-    class_id: int | None = None,
+    student_no: str | None = Query(default=None,description="按学号精确查询"),
+    student_name: str | None = Query(default=None,description="按名字模糊查询"),
+    class_id: int | None = Query(default=None,gt=0,description="按班级号精确查询"),
     # 获取本次请求使用的数据库连接
     db: Session = Depends(get_db),
+    page:int = Query(default=1,ge=1,description="页码，从1开始"),
+    page_size:int = Query(default=10,ge=1,le=100,description="每页条数,最多100条"),
 ):
     # 调用 DAO 查询数据库
-    students = student_dao.get_students(
+    total, students = student_dao.get_students(
         db=db,
         student_no=student_no,
         student_name=student_name,
         class_id=class_id,
+        page=page,
+        page_size=page_size,
     )
-
+    data = [
+        {
+            "id": student.id,
+            "student_no": student.student_no,
+            "student_name": student.student_name,
+            "class_id": student.class_id,
+            "consultant_id": student.consultant_id,
+            "native_place": student.native_place,
+            "graduation_school": student.graduation_school,
+            "major": student.major,
+            "enrollment_date": student.enrollment_date,
+            "graduation_date": student.graduation_date,
+            "education": student.education,
+            "age": student.age,
+            "gender": student.gender,
+        }
+        for student in students
+    ]
     return {
         "code": 200,
         "detail": "查询成功",
-        "total": len(students),
-        "data": students,
+        "total": total,
+        "page": page,
+        "page_size": page_size,
+        "data": data,
     }
 
 @student_router.get("/{id}", summary="查询学生详情")
-def get_student(id: int, db: Session = Depends(get_db)):
+def get_student(id: int = Path(gt=0),
+                db: Session = Depends(get_db)):
     # 根据路径中的 ID 查询学生
     student = student_dao.get_student_by_id(id, db)
 
@@ -73,10 +105,26 @@ def get_student(id: int, db: Session = Depends(get_db)):
         # 404 表示请求的数据不存在
         raise HTTPException(status_code=404, detail="学生不存在")
 
+    result = {
+            "id": student.id,
+            "student_no": student.student_no,
+            "student_name": student.student_name,
+            "class_id": student.class_id,
+            "consultant_id": student.consultant_id,
+            "native_place": student.native_place,
+            "graduation_school": student.graduation_school,
+            "major": student.major,
+            "enrollment_date": student.enrollment_date,
+            "graduation_date": student.graduation_date,
+            "education": student.education,
+            "age": student.age,
+            "gender": student.gender,
+        }
+
     return {
         "code": 200,
         "detail": "查询成功",
-        "data": student,
+        "data": result,
     }
 
 @student_router.delete("/{id}", summary="逻辑删除学生")

dao/class_dao.py

@@ -37,7 +37,7 @@ def get_classes_dao( class_id, class_no , class_name , page , page_size , db ):
         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()                                                             # tatal变量接收满足当前所有过滤条件的数据总条数
+    total = q.count()                                                             # total变量接收满足当前所有过滤条件的数据总条数
     r = q.offset( ( page-1 ) * page_size  ).limit( page_size ).all()              # 变量r用来接收查询取出结果列表，计算分页偏移量（从第几行开始查），设置分页限制条数
     return total , [                                                              # 返回 total变量总条数 和 将查询结果列表转换为字典列表的数据
                      {
@@ -54,6 +54,40 @@ def get_classes_dao( class_id, class_no , class_name , page , page_size , db ):
                     ]
 
 
+
+# ————定义查询符合查询条件的班级的总学生人数信息的函数————
+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
+    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
     try :                                       # 执行以下可能报错的代码

dao/score.py

@@ -1,4 +1,3 @@
-from sqlalchemy import DECIMAL
 from models.score import Score
 
 def post_score_dao(data_dict, db):
@@ -6,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:
@@ -31,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()
@@ -60,13 +74,19 @@ def get_score_dao(score_id, student_id, exam_seq, page, page_size, db):
     return total, res_list
 
 
+
+
+
+
 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/student.py

@@ -1,9 +1,7 @@
-from schemas.student import *
-from core.database import get_db
-from models.student import *
+from models.student import Student
 from sqlalchemy.orm import Session
 
-
+#新建学生
 def create_students(d: dict, db: Session):
     stu = Student(**d)
 
@@ -22,6 +20,7 @@ def create_students(d: dict, db: Session):
         print(f"插入学生失败: {e}")
         return None
 
+#查询学生是否已经被逻辑删除
 def get_student_by_id(student_id: int, db: Session):
     # 同时判断 is_deleted，已经逻辑删除的学生不会被查到
     return db.query(Student).filter(
@@ -29,6 +28,7 @@ def get_student_by_id(student_id: int, db: Session):
         Student.is_deleted == 0,
     ).first()
 
+#更新学生信息
 def update_student(student_id: int, data: dict, db: Session):
     # 第一步：先查询学生
     student = get_student_by_id(student_id, db)
@@ -54,11 +54,14 @@ def update_student(student_id: int, data: dict, db: Session):
         print("修改学生失败：", e)
         return False
 
+#允许条件输入的列表查询
 def get_students(
     db: Session,
     student_no: str | None = None,
     student_name: str | None = None,
     class_id: int | None = None,
+    page: int = 1,
+    page_size: int = 10,
 ):
     # 第一步：只查询没有被删除的学生
     query = db.query(Student).filter(Student.is_deleted == 0)
@@ -72,12 +75,22 @@ def get_students(
         # 姓名使用模糊查询，例如“张”可以查到“张三”
         query = query.filter(Student.student_name.like(f"%{student_name}%"))
 
-    if class_id:
         # 班级 ID 使用精确查询
-        query = query.filter(Student.class_id == class_id)
+    if class_id is not None:
+            query = query.filter(Student.class_id == class_id)
 
-    # 第三步：执行查询并返回全部结果
-    return query.all()
+    # 分页之前统计符合条件的总条数
+    total = query.count()
+
+    #默认按学生id排序
+    students = (
+        query
+        .order_by(Student.id.desc())
+        .offset((page - 1) * page_size)
+        .limit(page_size)
+        .all()
+    )
+    return total, students
 
 #逻辑删除学生
 def delete_student(student_id: int, db: Session):

schemas/class_schema.py

@@ -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/student.py

@@ -1,7 +1,8 @@
-from pydantic import BaseModel
 from datetime import date
 from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing import Literal
 
+#新建学生请求体
 class StudentCreate(BaseModel):
     student_no: str | None = Field(default=None, min_length=1, max_length=50)
     student_name: str = Field(min_length=1, max_length=50)
@@ -14,7 +15,7 @@ class StudentCreate(BaseModel):
     graduation_date: date | None = None
     education: str | None = Field(default=None, max_length=50)
     age: int = Field(ge=0, le=150)
-    gender: str = Field(min_length=1, max_length=10)
+    gender: Literal["男", "女"]
 
     @model_validator(mode="after")
     def check_dates(self):
@@ -23,18 +24,19 @@ class StudentCreate(BaseModel):
             raise ValueError("毕业日期不能早于入学日期")
         return self
 
+#更新学生请求体
 class StudentUpdate(BaseModel):
     # 全部设为可选，前端只传需要修改的字段
-    student_no: str | None = None
-    student_name: str | None = None
-    class_id: int | None = None
-    consultant_id: int | None = None
-    native_place: str | None = None
-    graduation_school: str | None = None
-    major: str | None = None
-    enrollment_date: date | None = None
-    graduation_date: date | None = None
-    education: str | None = None
-    age: int | None = None
-    gender: str | None = None
+        student_no: str | None = Field(default=None, min_length=1, max_length=50)
+        student_name: str | None = Field(default=None, min_length=1, max_length=50)
+        class_id: int | None = Field(default=None, gt=0)
+        consultant_id: int | None = Field(default=None, gt=0)
+        native_place: str | None = Field(default=None, max_length=100)
+        graduation_school: str | None = Field(default=None, max_length=100)
+        major: str | None = Field(default=None, max_length=100)
+        enrollment_date: date | None = None
+        graduation_date: date | None = None
+        education: str | None = Field(default=None, max_length=50)
+        age: int | None = Field(default=None, ge=0, le=150)
+        gender: Literal["男", "女"] | None = None