修改请求体

Reviewed-on: #43

api/class_api.py

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

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

@@ -29,38 +29,54 @@ 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()                                                             # tatal变量接收满足当前所有过滤条件的数据总条数
-    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 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/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):

models/class_model.py

@@ -5,7 +5,7 @@ from core.database import Base     # 从core软件包下的database模块导入B
 from sqlalchemy.dialects.mysql import TINYINT
 
 class Classes( Base ):              # 在python里的名字
-    __tablename__ = 'class_info_detail'       # 在数据库中表的名字
+    __tablename__ = 'class_info_detail'    # 在数据库中表的名字
     #————创建班级"主键"的字段名————
     id = Column( Integer                 # 声明字段的数据类型是"整数"
                , primary_key = True      # 声明是"主键"
@@ -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 = ''        # 返回的数据,默认为空字符串

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