删除了冗余查询接口，查询接口新增查询枚举性别功能

Reviewed-on: #52

.gitignore

@@ -8,6 +8,9 @@ __pycache__/
 .venv/
 venv/
 env/
+.env
+.env.local
+.local-data-backups/
 
 # IDE
 .idea/
@@ -15,4 +18,9 @@ env/
 
 # 系统垃圾
 .DS_Store
-Thumbs.db
+Thumbs.db
+
+
+.idea/
+.idea.backup/
+.run/

api/class_api.py

@@ -1,25 +1,56 @@
-from fastapi import APIRouter,Depends,HTTPException
-from schemas.class_schema import *
-from core.database import get_db
-from dao.class_dao import *
+# 班级api模块
+from fastapi import APIRouter,Depends,HTTPException    # 导入fastapi模块下的APIRouter,Depends,HTTPException
+from schemas.class_schema import *                     # 从schemas包下的class_schema模块导入所有请求体、响应体
+from core.database import get_db                       # 从core包下的database模块导入get_db上下文管理器，调用get_db函数可以自动开启关闭与数据库的会话
+from dao.class_dao import *                            # 从dao包下的class_dao模块导入所有函数
 
+# 实例化班级路由对象
 classes_router = APIRouter()
 
-@classes_router.post('/',response_model=ClassResponse)
-def post_classes(classes:ClassCreate,db=Depends(get_db)):
-    c = classes.model_dump()
-    r = post_classes_dao( c , db )
-    if r :
-        return ClassResponse( total=1,data=c )
-    else :
-        raise HTTPException(status_code=500,detail='添加失败，服务器繁忙，请稍后添加！')
+
+#以下分别定义增、删、改、查的路由的接口函数，以便api接口函数中执行
+
+# ————定义班级表"新增"信息的接口函数————
+@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
+        raise HTTPException(status_code=500,detail='添加失败，服务器繁忙，请稍后添加！') # 抛出 500 内部服务器错误 和提示
 
 
-@classes_router.put('/{id}',response_model=ClassResponse)
-def put_classes(id:int,classes:ClassUpdate,db=Depends(get_db)):
-    updates = classes.model_dump( exclude_unset=True )
-    r = update_classes_dao( id , db , updates )
-    if r :
-        return ClassResponse( total=1,data=updates )
-    else :
-        raise HTTPException(status_code=500, detail='更新失败，该班级已不存在或服务器繁忙，请稍后更新！')
+# ————定义班级表"更新"信息的接口函数————
+@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
+        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依赖于数据库会话的上下文管理器
+               ):
+    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响应，提示没有符合条件的提示给前端
+
+
+
+# ————定义班级表"删除"信息的接口函数————
+@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!=0 :                                     # 判断 DAO 层的返回结果，如果是True
+        return ClassResponse( total=1,data='已成功删除班级信息' )  # 返回成功响应和提示给前端                                                                    # 如果是False
+    raise HTTPException(status_code=500, detail='删除失败，该班级信息已不存在或服务器繁忙，请稍后更新！')  # 如果为False，抛出 500 内部服务器错误 和提示

api/consultant.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_db
+from schemas.consultant import ConsultantCreate, ConsultantUpdate, ConsultantResponse
+from dao import consultant as dao_consultant
+
+router = APIRouter()
+
+
+@router.get(
+    path="/consultants",
+    tags=['顾问管理模块'],summary='顾问模糊分页查询')
+def read_consultants(
+    db: Session = Depends(get_db),
+    page:int=1,
+    page_size:int=20,
+    name:str|None=None,
+    phone:str|None=None
+):
+    return dao_consultant.get_consultant_list(db, page, page_size, name, phone)
+
+
+
+@router.post("/consultants", response_model=ConsultantResponse,tags=['顾问管理模块'],summary='顾问增加')
+def create_consultant(
+    obj_in: ConsultantCreate,
+    db: Session = Depends(get_db)
+):
+    return dao_consultant.create_consultant(db, obj_in)
+
+
+@router.get("/consultants/{id}", response_model=ConsultantResponse,tags=['顾问管理模块'],summary='顾问查询')
+def read_consultant(id: int, db: Session = Depends(get_db)):
+    res = dao_consultant.get_consultant_by_id(db, cid=id)
+    if res is None:
+        raise HTTPException(status_code=404, detail="顾问不存在或已删除")
+    return res
+
+
+@router.put(
+    path="/consultants/{id}",
+    response_model=ConsultantResponse,
+    tags=['顾问管理模块'],summary='顾问更新')
+def update_consultant(
+    id: int,
+    obj_in: ConsultantUpdate,
+    db: Session = Depends(get_db)
+):
+    # model_dump 排除为None的字段，只更新前端传过来的字段
+    update_dict = obj_in.model_dump(exclude_none=True)
+    res = dao_consultant.update_consultant(db, cid=id, update_data=update_dict)
+    if res is None:
+        raise HTTPException(status_code=404, detail="顾问不存在或已删除")
+    return res
+
+
+
+@router.delete("/consultants/{id}", response_model=ConsultantResponse,tags=['顾问管理模块'],summary='顾问删除')
+def delete_consultant(id: int, db: Session = Depends(get_db)):
+    res = dao_consultant.delete_consultant(db, cid=id)
+    if res is None:
+        raise HTTPException(status_code=404, detail="顾问不存在或已删除")
+    return res

api/employment.py

@@ -0,0 +1,91 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from core.database import get_db
+from dao.employment import (create_employment,
+                            get_employment_by_id,
+                            get_employment_by_student_id,
+                            get_employment_list,
+                            update_employment,
+                            delete_employment_logic,
+                            recover_employment_delete)
+
+from schemas.employment import (EmploymentCreate,
+                                EmploymentUpdate,
+                                EmploymentResponse)
+
+employment_router = APIRouter( tags=["就业管理模块"])
+
+
+@employment_router.post("/", response_model=EmploymentResponse, summary="新增就业信息")
+def add_employment(body: EmploymentCreate, db: Session = Depends(get_db)):
+    """
+    新增就业信息
+    - 一个学生只能保存一条就业记录
+    - student_id必须在学生表student_info_detail中真实存在
+    """
+    res = create_employment(db, body)
+    if res is None:
+        raise HTTPException(status_code=500, detail="新增失败，学生id不存在或该学生已有就业记录")
+    return res
+
+
+#
+
+# @employment_router.get("/students/{student_id}", response_model=EmploymentResponse, summary="查询指定学生的就业信息")
+# def query_student_employment(student_id: int, db: Session = Depends(get_db)):
+#     """根据学生id获取对应就业记录"""
+#     record = get_employment_by_student_id(db, student_id)
+#     if not record:
+#         raise HTTPException(status_code=404, detail="未找到该学生的就业信息")
+#     return record
+
+
+@employment_router.get("/", summary="就业信息列表，支持筛选")
+def query_employment_list(eid:int| None = Query(None, description="就业编号"),
+                          student_id:int| None = Query(None,description="学生id"),
+                          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}
+
+
+# @employment_router.get("/{eid}", response_model=EmploymentResponse, summary="根据id查询就业详情")
+# def query_employment_detail(eid: int, db: Session = Depends(get_db)):
+#     """根据就业主键id查询单条就业记录"""
+#     record = get_employment_by_id(db, eid)
+#     if not record:
+#         raise HTTPException(status_code=404, detail="就业记录不存在或已被逻辑删除")
+#     return record
+
+
+@employment_router.put("/{eid}", response_model=EmploymentResponse, summary="修改就业信息")
+def edit_employment(eid: int, body: EmploymentUpdate, db: Session = Depends(get_db)):
+    """修改就业记录，只传想要修改的字段即可"""
+    res = update_employment(db, eid, body)
+    if res is None:
+        raise HTTPException(status_code=404, detail="修改失败，记录不存在")
+    return res
+
+
+@employment_router.delete("/{eid}", summary="逻辑删除就业记录")
+def logic_delete_employment(eid: int, db: Session = Depends(get_db)):
+    """执行逻辑删除，is_deleted置1，不会真正删除数据库行"""
+    ok = delete_employment_logic(db, eid)
+    if not ok:
+        raise HTTPException(status_code=404, detail="删除失败，记录不存在")
+    # 删除成功返回提示字典
+    return {"code": 200, "msg": "逻辑删除成功"}
+
+@employment_router.get("/{eid}", summary="回档逻辑删除就业记录")
+def recover_delete_employment(eid: int, db: Session = Depends(get_db)):
+    """执行逻辑删除，is_deleted置1，不会真正删除数据库行"""
+    ok = recover_employment_delete(db, eid)
+    if not ok:
+        raise HTTPException(status_code=404, detail="回档失败，记录已经存在")
+    # 删除成功返回提示字典
+    return {"code": 200, "msg": "回档成功"}

api/magic.py

@@ -0,0 +1,23 @@
+from fastapi import APIRouter, Depends, FastAPI
+from pydantic import BaseModel
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from magic_llm.llm_func import llm_func
+
+
+
+magic_router = APIRouter(tags=["智能数据库接口"])
+
+
+class MagicRequest(BaseModel):
+    user_request: str
+
+
+@magic_router.post("/magic")
+def Fastapi_magic(req: MagicRequest, db: Session = Depends(get_db)):
+    executor, code = llm_func(req.user_request)
+    return {"generated_code": code, "result": executor(db)}
+
+
+

api/score.py

@@ -0,0 +1,52 @@
+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 schemas.score import ScoreCreate, ScoreUpdate, ScorePageResp
+
+scores_router = APIRouter(prefix="/scores", tags=["成绩接口"])
+
+
+@scores_router.post("", summary="新增成绩接口")
+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="个人成绩查询接口")
+def list_score(
+    score_id: int|None=None,
+    student_id: int |None=None,
+    exam_seq: int|None=None,
+    page: int = Query(1, ge=1),
+    page_size: int = Query(10, ge=1, le=100),
+    db: Session = Depends(get_db)
+):
+    total, data_list = get_score_dao(score_id, student_id, exam_seq, 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)):
+    update_dict = req.model_dump(exclude_unset=True)
+    if not update_dict:
+        raise HTTPException(status_code=400, detail="没有传入任何修改字段")
+    ok = update_score_dao(score_id, db, update_dict)
+    if not ok:
+        raise HTTPException(status_code=400, detail="修改失败，记录不存在或已删除")
+    return {"msg": "修改成功"}
+
+
+@scores_router.delete("{score_id}", summary="删除成绩接口")
+def remove_score(score_id: int, db: Session = Depends(get_db)):
+    ok = delete_score_dao(score_id, db)
+    if not ok:
+        raise HTTPException(status_code=400, detail="删除失败，记录不存在或已删除")
+    return {"msg": "逻辑删除成功"}

api/statistics.py

@@ -1,16 +1,17 @@
 from fastapi import APIRouter,HTTPException,Depends
-from DoubaoTeam.core.database import get_db
-from DoubaoTeam.models.student import Student
-from DoubaoTeam.models.score import Score
-from DoubaoTeam.dao.statistics import *
-from DoubaoTeam.schemas.common import SuccessResponse
+from core.database import get_db
+from models.employment import Employment
+from models.student import Student
+from models.score import Score
+from dao.statistics import *
+from schemas.common import SuccessResponse
 from sqlalchemy.orm import Session
 
 
-statistics_router=APIRouter()
+statistics_router=APIRouter(tags=['统计接口'])
 
 
-@statistics_router.get("/scores/age-over-30",response_model=SuccessResponse)
+@statistics_router.get("/students/age-over-30",response_model=SuccessResponse)
 def api_age_over_thirty(db:Session=Depends(get_db)):
     try:
         age_over_thirty_list=age_over_thirty(Student,db)
@@ -26,3 +27,57 @@ def api_gender_count(db:Session=Depends(get_db)):
     except NoExist as e:
         raise HTTPException(status_code=404,detail=str(e))
 
+@statistics_router.get("/scores/all-above-80",response_model=SuccessResponse)
+def all_above_eighty(db:Session=Depends(get_db)):
+    try:
+        result = score_over_eighty(Score,Student,db)
+        return SuccessResponse(status_code=200,msg=result)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+
+@statistics_router.get("/scores/fail-more-than-two",response_model=SuccessResponse)
+def fail_two(db:Session=Depends(get_db)):
+    try:
+        result = twice_error(Score,Student,db)
+        return SuccessResponse(status_code=200,msg=result)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+
+@statistics_router.get("/scores/class-average",response_model=SuccessResponse)
+def class_average(db:Session=Depends(get_db)):
+    try:
+        result = avg_class(Score,Student,db)
+        return SuccessResponse(status_code=200,msg=result)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+
+
+@statistics_router.get("/employments/top5-salary",response_model=SuccessResponse)
+def top_salary(db:Session=Depends(get_db)):
+    try:
+        result=max_salary(Student,Employment,db)
+        return SuccessResponse(status_code=200,msg=result)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+
+@statistics_router.get("/employments/student-duration",response_model=SuccessResponse)
+def employ_time(db:Session=Depends(get_db)):
+    try:
+        result = student_market(Employment,db)
+        return SuccessResponse(status_code=200,msg=result)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+
+@statistics_router.get("/employments/class-average-duration",response_model=SuccessResponse)
+def avg_employ_time(db:Session=Depends(get_db)):
+    try:
+        result = avg_emptime(Employment,Student,db)
+        return SuccessResponse(status_code=200,msg=result)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+
+
+
+
+
+

api/student.py

@@ -1,14 +1,146 @@
-from fastapi import APIRouter,Depends,HTTPException
-from sqlalchemy.orm import Session
-from dao.student import *
-from schemas.student import StudentCreate
 
+from fastapi import APIRouter, Depends, HTTPException,Query,Path
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from schemas.student import StudentCreate, StudentUpdate, Gender
+from dao import student as student_dao
 student_router = APIRouter()
 
-@student_router.post("/student")
-def create_student(request:StudentCreate,db:Session,create = Depends(create_students)):
+@student_router.post("",summary='添加学生')
+def create_student(request:StudentCreate,db:Session = Depends(get_db)):
     d = request.model_dump()
-    r = create_students(d,db)
+    r = student_dao.create_students(d,db)
     if not r:
         raise HTTPException(status_code=500,detail='服务器繁忙，请稍后添加！')
-    return {'code':200,'detail':"添加学生成功"}
+    return {'code':200,'detail':"添加学生成功"}
+
+@student_router.put("/{id}", summary="更新学生信息")
+def update_student(
+    id: int,
+    request: StudentUpdate,
+    db: Session = Depends(get_db),
+):
+    # 只取前端真正传来的字段
+    # 例如只传 age，就只修改 age
+    data = request.model_dump(exclude_unset=True)
+
+    student = student_dao.update_student(id, data, db)
+
+    # None 表示学生不存在
+    if student is None:
+        raise HTTPException(status_code=404, detail="学生不存在")
+
+    # False 表示操作数据库失败
+    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="分页查询学生列表")
+def get_students(
+    # 三个查询条件都可以不传
+    gender:Gender = Query(default=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 查询数据库
+    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,
+        gender = gender
+    )
+    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": total,
+        "page": page,
+        "page_size": page_size,
+        "data": data,
+    }
+
+# @student_router.get("/{id}", summary="查询学生详情")
+# def get_student(id: int = Path(gt=0),
+#                 db: Session = Depends(get_db)):
+#     # 根据路径中的 ID 查询学生
+#     student = student_dao.get_student_by_id(id, db)
+#
+#     if not student:
+#         # 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": result,
+#     }
+
+@student_router.delete("/{id}", summary="逻辑删除学生")
+def delete_student(id: int, db: Session = Depends(get_db)):
+    student = student_dao.delete_student(id, db)
+
+    # None 表示不存在，或者以前已经删除
+    if student is None:
+        raise HTTPException(status_code=404, detail="学生不存在或已经删除")
+
+    if student is False:
+        raise HTTPException(status_code=500, detail="删除学生失败")
+
+    return {
+        "code": 200,
+        "detail": "删除学生成功",
+    }

api/teacher.py

@@ -0,0 +1,129 @@
+from typing import List
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core import database
+from core.database import get_db
+from schemas.teacher import TeacherOut, TeacherCreate, TeacherUpdate, ClassTeachersCreate, ClassTeacherOut
+# 导入dao层所有函数
+from models.teacher import Teacher
+from models.class_teacher import ClassTeachers
+from dao.teacher import (
+    get_teacher_list,
+    get_teacher_by_id,
+    create_teacher,
+    update_teacher,
+    delete_teacher,
+    get_class_teacher_by_class_id,
+    create_class_teacher,
+    update_class_teacher_full,
+    delete_class_teacher
+)
+
+router = APIRouter()
+
+#============================老师表===============================
+@router.get("/list", response_model=List[TeacherOut])
+def api_get_teacher_list(db: Session = Depends(get_db)):
+    """
+    GET 查询全部有效老师列表
+    :param db: 数据库会话，Depends自动注入
+    :return: List[TeacherOut] 老师列表，使用TeacherOut做响应格式化
+    """
+    return get_teacher_list(db)
+
+@router.get("/{teacher_id}", response_model=TeacherOut)
+def api_get_teacher_by_id(teacher_id: int,db: Session = Depends(get_db)):
+    """
+        根据老师主键ID查询单个有效老师
+        :param teacher_id: int 老师表主键ID
+        :param db: Session 数据库会话对象，依赖注入自动获取
+        :return: TeacherOut 老师详情信息
+    """
+    return get_teacher_by_id(db,teacher_id)
+@router.post("", response_model=TeacherOut, summary="新增老师")
+def api_create_teacher(obj: TeacherCreate, db: Session = Depends(get_db)):
+    """
+    新增老师记录，自动校验姓名、编号唯一性，并自动生成老师业务编号
+    :param obj: TeacherCreate Pydantic模型，前端提交新增老师表单数据
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: TeacherOut 新增成功后的老师完整信息
+    """
+    return create_teacher(db, obj)
+@router.put("/{teacher_id}", response_model=TeacherOut, summary="修改老师信息（局部更新）")
+def api_update_teacher(teacher_id: int, obj: TeacherUpdate, db: Session = Depends(get_db)):
+    """
+    修改老师信息，支持局部更新，仅更新前端传入的字段
+    :param teacher_id: int 需要修改的老师主键ID
+    :param obj: TeacherUpdate Pydantic模型，前端提交待修改字段
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: TeacherOut 更新后的老师完整信息
+    """
+    db_teacher = get_teacher_by_id(db, teacher_id)
+    if not db_teacher:
+        raise HTTPException(status_code=404, detail="老师不存在或已删除！")
+    result = update_teacher(db, teacher_id, obj)
+    return result
+@router.delete("/{teacher_id}", summary="逻辑删除老师")
+def api_delete_teacher(teacher_id: int, db: Session = Depends(get_db)):
+    """
+    逻辑删除老师，存在有效班级带班关系时禁止删除
+    :param teacher_id: int 需要删除的老师主键ID
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: dict 操作成功提示
+    """
+    result = delete_teacher(db, teacher_id)
+    if not result:
+        raise HTTPException(status_code=404, detail="老师不存在或已删除！")
+    return {"msg": "老师逻辑删除成功"}
+
+# ===================== 班级老师关联路由组 =====================
+class_teacher_router = APIRouter()
+
+@class_teacher_router.get("/class/{class_id}", response_model=List[ClassTeacherOut], summary="根据班级ID查询该班级所有带班老师")
+def api_get_class_teacher_by_class_id(class_id: int, db: Session = Depends(get_db)):
+    """
+    根据班级主键ID，查询该班级全部有效的班级-老师绑定记录
+    :param class_id: int 班级表主键ID
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: List[ClassTeachersOut] 班级老师关联记录列表
+    """
+    return get_class_teacher_by_class_id(db, class_id)
+
+@class_teacher_router.post("", response_model=ClassTeacherOut, summary="分配老师到班级，新增班级老师关联记录")
+def api_create_class_teacher(obj: ClassTeachersCreate, db: Session = Depends(get_db)):
+    """
+    新增班级与老师的绑定关系，做重复性校验与老师有效性校验
+    :param obj: ClassTeachersCreate Pydantic模型，前端提交class_id、teacher_id、role
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: ClassTeachersOut 新增成功后的班级老师关联记录
+    """
+    return create_class_teacher(db, obj)
+
+@class_teacher_router.put("/{rel_id}", response_model=ClassTeacherOut, summary="更新班级老师绑定关系")
+def api_update_class_teacher_full(rel_id: int, obj: ClassTeachersCreate, db: Session = Depends(get_db)):
+    """
+    修改班级老师中间表记录，支持修改class_id、teacher_id、role；自动校验老师有效性、三元组合唯一性
+    :param rel_id: int class_teachers中间表主键ID（待修改的关联记录id）
+    :param obj: ClassTeachersCreate Pydantic模型，前端提交新的class_id、teacher_id、role
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: ClassTeachersOut 更新后的班级老师关联记录
+    """
+    result = update_class_teacher_full(db, rel_id, obj)
+    if not result:
+        raise HTTPException(status_code=404, detail="班级老师关联记录不存在！")
+    return result
+
+@class_teacher_router.delete("/{rel_id}", summary="逻辑删除班级老师带班关联")
+def api_delete_class_teacher(rel_id: int, db: Session = Depends(get_db)):
+    """
+    逻辑删除班级老师绑定关系，修改is_deleted标记为1，非物理删除
+    :param rel_id: int class_teachers中间表主键ID
+    :param db: Session 数据库会话对象，依赖注入自动获取
+    :return: dict 操作成功提示
+    """
+    result = delete_class_teacher(db, rel_id)
+    if not result:
+        raise HTTPException(status_code=404, detail="班级老师关联记录不存在！")
+    return {"msg": "解除班级带班关系成功"}
+
+

dao/class_dao.py

@@ -1,29 +1,82 @@
-from models.class_model import Classes
+# 班级dao模块
+from models.class_model import Classes    # 从models包里的class_model班级模块导入Classes表模型类
+
+#以下分别定义增、删、改、查的依赖函数，以便api接口函数中执行
+
+# ————定义班级表"新增"信息的函数————
+def post_classes_dao( c , db ):                  # 定义函数，设置两个形参c，db
+    try :                                        # 执行以下可能报错的代码
+        cc = Classes( **c )                      # 将接口函数接收的字典数据解包，实例化为 Classes 模型对象
+        db.add( cc )                             # 将模型对象加入当前数据库会话（尚未真正写入数据库）
+    except :                                     # 捕获异常：
+        db.rollback()                            # 如果中间出错，回滚事务，防止产生脏数据
+        return False                             # 返回 False，返回接口，表示操作失败
+    else :                                       # 执行成功：
+        db.commit()                              # 提交事务：将数据真正持久化写入到数据库中
+        return True                              # 返回 True，返回接口，表示操作成功
 
 
-def post_classes_dao( c , db ):
-    try :
-        cc = Classes( **c )
-        db.add( cc )
-    except :
-        db.rollback()
-        return False
-    else :
-        db.commit()
-        return True
+# ————定义班级表"更新"信息的函数————
+def update_classes_dao( class_id , db , updates ):     # 定义函数，设置三个形参class_id，db ，updates
+    try :                                              # 执行以下可能报错的代码
+        db.query(Classes).filter(Classes.id ==class_id , Classes.is_deleted == 0 ).update(updates) # 将接口函数接收的更新数据更新到Classes模型对象，条件是未删除且前端输入的id和数据库id可以匹配上的
+    except :                                           # 捕获异常：
+        db.rollback()                                  # 如果中间出错，回滚事务，防止产生脏数据
+        return False                                   # 返回 False，返回接口，表示操作失败
+    else :                                             # 执行成功：
+        db.commit()                                    # 提交事务：将数据真正持久化写入到数据库中
+        return True                                    # 返回 True，返回接口，表示操作成功
 
-def update_classes_dao( class_id , db , updates ):
-    try :
-        db.query( Classes ).filter( Classes.id==class_id , Classes.is_deleted==0 ) .update( updates )
-    except :
-        db.rollback()
-        return False
-    else :
-        db.commit()
-        return True
 
-# def get_classes_dao( class_id , class_name ,  db ):
-#     try :
-#         r = db.query( Classes ).filter( Classes.id==class_id , Classes.is_deleted==0 ) .all()
-#     except :
-#         db.rollback()
+# ————定义班级表"查询"信息的函数————
+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 :                                       # 执行以下可能报错的代码
+        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，返回接口，表示操作失败

dao/consultant.py

@@ -0,0 +1,82 @@
+from models.consultant import Consultant
+from schemas.consultant import ConsultantCreate, ConsultantUpdate
+from sqlalchemy.orm import Session
+def create_consultant(db:Session, obj_in: ConsultantCreate):
+    try:
+        db_obj = Consultant(**obj_in.model_dump())
+        db.add(db_obj)
+    except:
+        db.rollback()
+        return False
+    else:
+        db.commit()
+        return db_obj
+# 查询全部可分页（过滤已删除）
+def get_consultant_list(
+    db: Session,
+    page: int = 1,
+    page_size: int = 20,
+    name: str | None = None,
+    phone: str | None = None
+):
+    page_size = max(1, min(page_size, 100))
+    skip = (page - 1) * page_size
+
+    query = db.query(Consultant).filter(Consultant.is_deleted == 0)
+    # 有传参数才追加过滤条件
+    if name:
+        query = query.filter(Consultant.consultant_name.like(f"%{name}%"))
+    if phone:
+        query = query.filter(Consultant.phone.like(f"%{phone}%"))
+
+    total = query.count()
+    items = query.offset(skip).limit(page_size).all()
+
+    return {
+        "items": items,
+        "total": total,
+        "page": page,
+        "page_size": page_size
+    }
+
+
+
+# 根据id查单条
+def get_consultant_by_id(db:Session, cid: int):
+    return db.query(Consultant).filter(Consultant.id == cid, Consultant.is_deleted == 0 ).first()
+
+
+# 修改
+def update_consultant(db: Session, cid: int, update_data: dict):
+    try:
+        db_obj = db.query(Consultant).filter(
+            Consultant.id == cid,
+            Consultant.is_deleted == 0
+        ).first()
+        if not db_obj:
+            return None
+        # 循环赋值
+        for k, v in update_data.items():
+            setattr(db_obj, k, v)
+        db.commit()
+        db.refresh(db_obj)  # 刷新从数据库拿最新数据（updated_at）
+        return db_obj
+    except Exception:
+        db.rollback()
+        return None
+
+
+
+# 逻辑删除（只改is_deleted=1）
+def delete_consultant(db:Session, cid: int):
+    try:
+        db_obj = get_consultant_by_id(db, cid)
+        if not db_obj:
+            return None
+        db_obj.is_deleted = 1
+    except:
+            db.rollback()
+            return None
+    else:
+            db.commit()
+            return db_obj

dao/employment.py

@@ -0,0 +1,172 @@
+from models.employment import Employment
+from schemas.employment import  EmploymentResponse
+
+
+def create_employment(db, e):
+    # obj_in是Pydantic对象(EmploymentCreate)
+    """新增就业信息：一个学生只能存在一条就业记录"""
+    try:
+        db_obj = Employment(**e.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()
+
+    except Exception:
+        db.rollback()
+        return None
+
+
+def get_employment_by_id(db, eid):
+    """根据主键id查询就业详情，过滤逻辑删除"""
+    try:
+        db_obj = db.query(Employment).filter(Employment.id == 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()
+    except Exception:
+        return None
+
+
+def get_employment_by_student_id(db, student_id):
+    """根据学生id查询就业信息，过滤逻辑删除"""
+    try:
+        db_obj = db.query(Employment).filter(Employment.student_id == 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()
+    except Exception:
+        return None
+
+
+def get_employment_list(db, id=None,student_id=None,company_name=None, salary_min=None, salary_max=None, skip=0, limit=20):
+    """就业列表查询；支持公司名模糊、薪资范围筛选；只查询is_deleted=0"""
+    try:
+        query = db.query(Employment).filter(Employment.is_deleted == 0)
+        if id is not None:
+            query = query.filter(Employment.id >= id)
+        if student_id is not None:
+            query = query.filter(Employment.student_id >= student_id)
+        if company_name:
+            query = query.filter(Employment.company_name.like(f"%{company_name}%"))
+        if salary_min is not None:
+            query = query.filter(Employment.salary >= salary_min)
+        if salary_max is not None:
+            query = query.filter(Employment.salary <= salary_max)
+
+        total = query.count()
+        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())
+
+        return dict_list, total
+    except Exception:
+        return [], 0
+
+
+def update_employment(db, eid, e):
+    """修改就业信息，只更新传入的字段"""
+    try:
+        x = db.query(Employment).filter(Employment.id == eid
+                                                 ,Employment.is_deleted == 0).first()
+        if x is None:
+            return None
+
+        update_dict = e.model_dump(exclude_unset=True)
+        db.query(Employment).filter(Employment.id == eid
+                                    ,Employment.is_deleted == 0).update(update_dict)
+
+        db.commit()
+        db.refresh(x)
+
+        resp = EmploymentResponse(id=x.id
+                                  ,student_id=x.student_id
+                                  ,employment_status=x.employment_status
+                                  ,employment_open_date=x.employment_open_date
+                                  ,offer_date=x.offer_date
+                                  ,company_name=x.company_name
+                                  ,salary=x.salary
+                                  ,remark=x.remark
+                                  ,created_at=x.created_at
+                                  ,updated_at=x.updated_at)
+        return resp.model_dump()
+
+    except Exception:
+        db.rollback()
+        return
+
+
+
+def delete_employment_logic(db, eid):
+    """逻辑删除，只修改is_deleted=1，不做物理删除"""
+    try:
+        y = db.query(Employment).filter(Employment.id == eid
+                                                 ,Employment.is_deleted == 0).first()
+        if y is None:
+            return False
+        y.is_deleted = 1
+        db.commit()
+        return True
+    except Exception:
+        db.rollback()
+        return False
+
+def recover_employment_delete(db, eid):
+    """逻辑删除，只修改is_deleted=1，不做物理删除"""
+    try:
+        y = db.query(Employment).filter(Employment.id == eid).first()
+        if y is None:
+            return False
+        y.is_deleted = 0
+        db.commit()
+        return True
+    except Exception:
+        db.rollback()
+        return False

dao/score.py

@@ -0,0 +1,106 @@
+from models.score import Score
+
+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:
+        return True
+
+
+def update_score_dao(score_id, db, updates):
+    """修改成绩，query.update方式"""
+    try:
+        cnt = 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)
+        db.rollback()
+        return False
+    else:
+        db.commit()
+        return True
+
+
+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:
+            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()
+
+    res_list = [
+        {
+            "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
+
+
+
+
+
+
+def delete_score_dao(score_id, db):
+    try:
+        cnt = db.query(Score).filter(
+            Score.id == score_id,
+            Score.is_deleted == 0
+        ).update({"is_deleted": 1})     # ← 接住返回值
+        if cnt == 0:                    # ← 关键：一行都没匹配到
+            db.rollback()
+            return False
+    except Exception as err:
+        print("删除成绩异常：", err)
+        db.rollback()
+        return False
+    else:
+        db.commit()
+        return True
+
+
+def exist_student_exam_dao(student_id, exam_seq, db):
+    """校验：同一个学生+考试序次是否已经存在，用于联合唯一业务判断"""
+    rec = db.query(Score).filter(
+        Score.student_id == student_id,
+        Score.exam_seq == exam_seq,
+        Score.is_deleted == 0
+    ).first()
+    return rec is not None

dao/statistics.py

@@ -1,30 +1,139 @@
-from DoubaoTeam.schemas.statistics import NoExist
+from schemas.statistics import NoExist
 from sqlalchemy import func
 
 #`GET /statistics/students/age-over-30`
 #查询所有超过 30 岁的学员信息
 
 def age_over_thirty(Student,db):
-    student_list=db.query(Student).filter(Student.age>=30).all()
+    student_list=db.query(Student).filter(Student.age>30,Student.is_deleted==0).all()
     if not student_list :
         raise NoExist('无目标年龄大于30岁')
-    return student_list
+    # 把每个学生对象需要返回的字段，明确放进普通字典。
+    result = []
+    for student in student_list:
+        result.append({
+            "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,
+            "create_at": student.create_at,
+            "update_at": student.update_at,
+            "is_deleted": student.is_deleted,
+        })
+    return result
 
 def gender_count(Student,db):
-    result=db.query(Student.class_id,Student.gender,func.count(Student.id)).group_by(Student.class_id,Student.gender).all()
+    result=db.query(Student.class_id,Student.gender,func.count(Student.id)).filter(Student.is_deleted==0).group_by(Student.class_id,Student.gender).all()
     if not result :
         raise NoExist('班里招点人吧，要倒闭了')
     dict1 = {}
     for i,j,k in result:
         if i not in dict1 :
-            dict1[i]={'男':0,'女':0}
-        dict[i][j]+=k
+            dict1[i]={'男':0,'女':0,'总人数':0}
+        dict1[i][j]+=k
+        dict1[i]['总人数']+=k
     return dict1
 #查询每次考试成绩都在 80 分以上的学生编号、姓名和成绩
 def score_over_eighty(Score,Student,db):
     student_list=db.query(Student.id, Student.student_name)\
-                  .join(Student,Score.student_id==Student.id).group_by(Student.student_no,Student.student_name)\
+                  .join(Score,Score.student_id==Student.id).filter(Student.is_deleted==0,Score.is_deleted==0).group_by(Student.id,Student.student_name)\
                   .having(func.min(Score.score)>80).all()
+    if not student_list :
+        raise NoExist('全是学渣')
+    list1 = []
     for i in student_list:
-        student_list2 = db.query(Student.student_no, Student.student_name,Score.score).join(Student,Score.student_id==Student.id).filter(i.id==Student.id).all()
+        student_list2 = db.query(Student.student_no, Student.student_name,Score.score).join(Score,Score.student_id==Student.id).filter(i.id==Student.id,Score.is_deleted==0).all()
+        if student_list2 :
+            for student_no, student_name, score in student_list2:
+                list1.append({
+                    "student_no": student_no,
+                    "student_name": student_name,
+                    "score": float(score) if score is not None else None,
+                })
+    return list1
+#查询有两次以上不及格的学生姓名、班级和不及格成绩
+def twice_error(Score,Student,db):
+    student_list=db.query(Score.student_id).filter(Score.score<60,Score.is_deleted==0).group_by(Score.student_id).having(func.count(Score.id)>2).all()
+    if not student_list :
+        raise NoExist('全是学霸')
+    list1=[]
+    for i in student_list:
+        result=db.query(Student.student_name,Student.class_id,Score.score).join(Score, Student.id==Score.student_id)\
+        .filter(i.student_id==Score.student_id,Score.score<60,Student.is_deleted==0,Score.is_deleted==0).all()
+        for student_name, class_id, score in result:
+            list1.append({
+                "student_name": student_name,
+                "class_id": class_id,
+                "score": float(score) if score is not None else None,
+            })
+    return list1
+
+#统计每次考试每个班级的平均分，并按照平均分从高到低排序
+def avg_class(Score,Student,db):
+    student_list = db.query(Student.class_id,Score.exam_seq,func.avg(Score.score)).join(Score, Student.id == Score.student_id).filter(Score.is_deleted==0,Student.is_deleted==0).group_by(Student.class_id,Score.exam_seq).order_by(func.avg(Score.score).desc()).all()
+    if not student_list :
+        raise NoExist('招个人吧')
+    result = []
+    for class_id, exam_seq, average_score in student_list:
+        result.append({
+            "class_id": class_id,
+            "exam_seq": exam_seq,
+            "average_score": float(average_score) if average_score is not None else None,
+        })
+    return result
+
+#统计就业薪资最高的前五名学生姓名、班级、就业时间、就业公司
+def max_salary(Student,Employment,db):
+    student_list = db.query(Student.student_name,Student.class_id,Employment.offer_date,Employment.company_name).join(Employment, Student.id == Employment.student_id).filter(Student.is_deleted==0,Employment.is_deleted==0).order_by(Employment.salary.desc()).limit(5).all()
+    if not student_list :
+        raise NoExist('没就业的啊兄弟？')
+    result = []
+    for student_name, class_id, offer_date, company_name in student_list:
+        result.append({
+            "student_name": student_name,
+            "class_id": class_id,
+            "offer_date": offer_date,
+            "company_name": company_name,
+        })
+    return result
+
+# - 统计每个学生的就业时长
+# - 就业时长 = `offer_date - employment_open_date`
+def student_market(Employment,db):
+    student_list = db.query(Employment.student_id,func.datediff(Employment.offer_date,Employment.employment_open_date)).filter(Employment.is_deleted==0).all()
+    result = []
+    for student_id, duration_days in student_list:
+        result.append({
+            "student_id": student_id,
+            "duration_days": duration_days,
+        })
+    return result
+
+# - 统计每个班级的平均就业时长
+# - 只统计有就业开放时间的学生
+def avg_emptime(Employment,Student,db):
+    student_list = (db.query(Student.class_id,\
+                            func.avg(func.datediff(Employment.offer_date,Employment.employment_open_date)))\
+                    .join(Employment, Student.id==Employment.student_id).filter(Student.is_deleted==0,Employment.is_deleted==0,Employment.employment_open_date.is_not(None)))\
+    .group_by(Student.class_id).all()
+    if not student_list :
+        raise NoExist('一个就业都没有吗')
+    result = []
+    for class_id, average_days in student_list:
+        result.append({
+            "class_id": class_id,
+            "average_days": float(average_days) if average_days is not None else None,
+        })
+    return result
+
+
 

dao/student.py

@@ -1,16 +1,124 @@
-from schemas.student import *
-from core.database import get_db
-from models.student import *
-from utils.code_generator import generate_no
+from models.student import Student
+from sqlalchemy.orm import Session
+
+from schemas.student import Gender
 
 
-def create_students(d,db):
+#新建学生
+def create_students(d: dict, db: Session):
     stu = Student(**d)
+
     try:
         db.add(stu)
-        generate_no("student_no", "STU", stu, db)
+        #  把 SQL 发给数据库执行
+        db.flush()
+        # 根据 id 生成学生编号
+        if not stu.student_no:
+            stu.student_no = f"STU{stu.id:04d}"
         db.commit()
-    except:return False
-    else:
-        return True
+        db.refresh(stu)
+        return stu
+    except Exception as e:
+        db.rollback()
+        print(f"插入学生失败: {e}")
+        return None
+
+#查询学生是否已经被逻辑删除
+def get_student_by_id(student_id: int, db: Session):
+    # 同时判断 is_deleted，已经逻辑删除的学生不会被查到
+    return db.query(Student).filter(
+        Student.id == student_id,
+        Student.is_deleted == 0,
+    ).first()
+
+#更新学生信息
+def update_student(student_id: int, data: dict, db: Session):
+    # 第一步：先查询学生
+    student = get_student_by_id(student_id, db)
+
+    # 没有查到就返回 None
+    if not student:
+        return None
+
+    try:
+        # 第二步：循环修改前端传来的字段
+        # field 是字段名，value 是新的值
+        for field, value in data.items():
+            setattr(student, field, value)
+
+        # 第三步：提交修改并重新读取数据
+        db.commit()
+        db.refresh(student)
+        return student
+
+    except Exception as e:
+        # 修改失败时回滚
+        db.rollback()
+        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,
+    gender: Gender = None,
+):
+    # 第一步：只查询没有被删除的学生
+    query = db.query(Student).filter(Student.is_deleted == 0)
+
+    # 第二步：前端传了哪个条件，就增加哪个条件
+    if student_no:
+        # 学号使用精确查询
+        query = query.filter(Student.student_no == student_no)
+
+    if gender:
+        #查询枚举性别
+        query = query.filter(Student.gender == gender)
+
+    if student_name:
+        # 姓名使用模糊查询，例如“张”可以查到“张三”
+        query = query.filter(Student.student_name.like(f"%{student_name}%"))
+
+        # 班级 ID 使用精确查询
+    if class_id is not None:
+            query = query.filter(Student.class_id == class_id)
+
+    # 分页之前统计符合条件的总条数
+    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):
+    # 第一步：查询学生
+    student = get_student_by_id(student_id, db)
+
+    if not student:
+        return None
+
+    try:
+        # 第二步：不真正删除记录，只把删除标记改成 1
+        student.is_deleted = 1
+
+        # 第三步：提交修改
+        db.commit()
+        return student
+
+    except Exception as e:
+        # 删除失败时回滚
+        db.rollback()
+        print("删除学生失败：", e)
+        return False
 

dao/teacher.py

@@ -0,0 +1,236 @@
+from sqlalchemy.orm import Session
+from core import database
+from models.teacher import Teacher
+from models.class_teacher import ClassTeachers
+from schemas.teacher import TeacherUpdate, TeacherCreate,ClassTeachersCreate
+from utils.code_generator import generate_no
+from fastapi import HTTPException
+
+'''
+本文件内容为老师表与班级老师关系表的增删改查函数集合
+'''
+#=================老师表Teacher的CRUD================
+#查询所有未被删除的老师
+def get_teacher_list(db:Session):
+    #查询老师列表，过滤逻辑删除
+    return db.query(Teacher).filter(Teacher.is_deleted == 0).all()
+#根据id,查询单个符合条件的老师
+def get_teacher_by_id(db:Session,teacher_id:int,):
+    return db.query(Teacher).filter(Teacher.id == teacher_id
+                                    ,Teacher.is_deleted == 0).first()
+#新增
+def create_teacher(db:Session,obj:TeacherCreate):
+    '''
+    新增
+    :param db: Session 数据库会话
+    :param obj:TeacherCreate 前端传入新增数据
+    :return: db_teacher 新增成功的ORM对象
+    业务逻辑：
+        1、查重：同名有效老师不能重复新增
+        2、如果前端手动添加teacher_no，校验编号不能和已有有效老师编号重复
+        3、创建ORM对象加入会话
+        4、调用generate_no，走动生成业务编号
+        5、commit提交事务入库，refresh刷新对象
+    '''
+    exist_teacher = db.query(Teacher).filter(Teacher.teacher_name == obj.teacher_name
+                                             ,Teacher.is_deleted == 0).first()
+    if exist_teacher:
+        raise HTTPException(status_code=409,detail='该用户已存在')
+    if obj.teacher_no:
+        exist_teacher = db.query(Teacher).filter(Teacher.teacher_no == obj
+                                                 .teacher_no,Teacher.is_deleted == 0).first()
+        if exist_teacher:
+            raise HTTPException(status_code=409,detail='老师编号已存在')
+    #开始添加
+    data = obj.model_dump(exclude_none=True)
+    db_teacher = Teacher(**data)
+    db.add(db_teacher)
+    # 调用公共函数生成业务编号，内部执行db.flush拿到自增id
+    generate_no('teacher_no','TCH',db_teacher,db)
+    db.commit()
+    db.refresh(db_teacher)
+    #从数据库重新查询这条记录，刷新 db_teacher 对象。
+    #作用：同步数据库默认字段的值，例如`created_at`、`updated_at`，拿到数据库里最新的数据，
+    # 最终返回给前端。
+    return db_teacher
+#更新
+def update_teacher(db:Session,teacher_id:int,obj:TeacherUpdate):
+    """
+        修改老师信息，局部更新
+        :param db: Session 数据库会话
+        :param teacher_id: int 需要修改的老师id
+        :param obj: TeacherUpdate 前端传入要修改的字段
+        :return: db_teacher ORM对象 / None
+    """
+    # 调用get_teacher_by_id校验用户是否存在
+    db_teacher = get_teacher_by_id(db,teacher_id)
+    if obj.teacher_name:
+        exist_teacher = db.query(Teacher).filter(
+            Teacher.teacher_name == obj.teacher_name,
+            Teacher.id != teacher_id,
+            Teacher.is_deleted == 0
+        ).first()
+        if exist_teacher:
+            raise HTTPException(status_code=409, detail="该姓名已被其他老师占用！")
+    if obj.teacher_no:
+        exist_no = db.query(Teacher).filter(
+            Teacher.teacher_no == obj.teacher_no,
+            Teacher.id != teacher_id,
+            Teacher.is_deleted == 0
+        ).first()
+        if exist_no:
+            raise HTTPException(status_code=409, detail="老师编号已被其他老师占用！")
+    #用户存在，解析键值对，循环使用setattr添加
+    update_data = obj.model_dump(exclude_none=True)
+    for k, v in update_data.items():
+        setattr(db_teacher, k, v)
+    db.commit()
+    db.refresh(db_teacher)
+    return db_teacher
+#删除
+def delete_teacher(db:Session,teacher_id:int):
+    """
+        逻辑删除老师，不是物理删除；修改is_deleted=1
+        :param db: Session
+        :param teacher_id:老师主键id
+        :return: Teacher ORM对象，找不到返回None
+        业务限制：老师已经分配班级，则不允许删除，防止脏数据
+    """
+    # 查询目标老师
+    db_teacher = get_teacher_by_id(db, teacher_id)
+    if not db_teacher:
+        return None
+
+    # 校验：查询班级老师中间表，判断该老师是否还有有效带班关系
+    rel = db.query(ClassTeachers).filter(
+        ClassTeachers.teacher_id == teacher_id,
+        ClassTeachers.is_deleted == 0
+    ).first()
+    if rel:
+        raise HTTPException(
+            status_code=400,
+            detail="该老师已分配班级，不能删除，请先解除带班关系！"
+        )
+
+    # 逻辑删除标记
+    db_teacher.is_deleted = 1
+    db.commit()
+    return db_teacher
+
+#==================班级老师中间表 CRUD=====================
+#查询
+def get_class_teacher_by_class_id(db: Session, class_id: int):
+    """
+    根据班级id，查询该班级所有有效的带班老师关系
+    :param db: Session
+    :param class_id:班级主键
+    :return: list[ClassTeacher]
+    """
+    return (
+        db.query(ClassTeachers)
+        .filter(ClassTeachers.class_id == class_id
+                ,ClassTeachers.is_deleted == 0)
+        .all()
+    )
+
+#新增
+def create_class_teacher(db: Session, obj: ClassTeachersCreate):
+    """
+    分配老师到班级，新增班级-老师关系记录
+    :param db: Session
+    :param obj: ClassTeacherCreate class_id、teacher_id、role
+    :return: ClassTeacher ORM对象
+    校验：
+        1.老师必须存在且未删除
+        2.同一班级同一个老师同一个角色不能重复分配
+    """
+    # 校验老师是否存在
+    teacher = get_teacher_by_id(db, obj.teacher_id)
+    if not teacher:
+        raise HTTPException(status_code=404, detail="老师不存在或已删除！")
+
+    # 查重：同一班级+同一老师+同一角色不能重复分配
+    rel = db.query(ClassTeachers).filter(
+        ClassTeachers.class_id == obj.class_id,
+        ClassTeachers.teacher_id == obj.teacher_id,
+        ClassTeachers.role == obj.role,
+        ClassTeachers.is_deleted == 0
+    ).first()
+    if rel:
+        raise HTTPException(status_code=409, detail="该老师已以相同角色分配到该班级！")
+
+    data = obj.model_dump()
+    db_obj = ClassTeachers(**data)
+    db.add(db_obj)
+    db.commit()
+    db.refresh(db_obj)
+
+    return db_obj
+
+#更新
+def update_class_teacher_full(db: Session, rel_id: int, obj: ClassTeachersCreate):
+    """
+    完整更新班级老师关系：可修改 class_id、teacher_id、role
+    :param db: Session
+    :param rel_id: 中间表主键
+    :param obj: ClassTeacherCreate 传入的新参数
+    :return: ClassTeacher ORM对象
+    校验：
+        1. 关系记录存在且未删除
+        2. 如果修改teacher_id，校验老师必须有效存在
+        3. 校验新组合(class_id+teacher_id+role)不能和其他有效记录重复
+    """
+    # 1. 查询原有记录
+    db_rel = db.query(ClassTeachers).filter(
+        ClassTeachers.id == rel_id,
+        ClassTeachers.is_deleted == 0
+    ).first()
+    if not db_rel:
+        return None
+
+    # 2. 如果老师ID发生变化，校验老师是否有效
+    if obj.teacher_id != db_rel.teacher_id:
+        teacher = get_teacher_by_id(db, obj.teacher_id)
+        if not teacher:
+            raise HTTPException(status_code=404, detail="老师不存在或已删除！")
+
+    # 3. 查重：新的三元组合不能重复（排除自身这条记录）
+    exist_rel = db.query(ClassTeachers).filter(
+        ClassTeachers.class_id == obj.class_id,
+        ClassTeachers.teacher_id == obj.teacher_id,
+        ClassTeachers.role == obj.role,
+        ClassTeachers.is_deleted == 0,
+        ClassTeachers.id != rel_id
+    ).first()
+    if exist_rel:
+        raise HTTPException(status_code=409, detail="该老师已以相同角色分配到该班级！")
+
+    # 赋值更新
+    db_rel.class_id = obj.class_id
+    db_rel.teacher_id = obj.teacher_id
+    db_rel.role = obj.role
+
+    db.commit()
+    db.refresh(db_rel)
+    return db_rel
+
+
+#删除
+def delete_class_teacher(db: Session, rel_id: int):
+    """
+    逻辑删除班级老师带班关系
+    :param db: Session
+    :param rel_id: class_teachers表主键id
+    :return: ClassTeacher ORM对象，找不到返回None
+    """
+    db_obj = (
+        db.query(ClassTeachers)
+        .filter(ClassTeachers.id == rel_id, ClassTeachers.is_deleted == 0)
+        .first()
+    )
+    if not db_obj:
+        return None
+
+    db_obj.is_deleted = 1
+    db.commit()
+    return db_obj

database.py

@@ -0,0 +1,13 @@
+from models import *
+from core.database import *
+from sqlalchemy import create_engine
+
+
+db_url = "mysql+pymysql://root:123456@127.0.0.1:3306/student_manager?charset=utf8mb4"
+engine = create_engine(db_url
+                       ,pool_size=50
+                       ,echo=True)
+
+Base.metadata.create_all(engine)
+db = SessionLocal()
+db.commit() #创建全部表

docs/学生模块答辩演示步骤.md

@@ -0,0 +1,472 @@
+# 学生模块答辩演示步骤
+
+> 演示目标：通过 Swagger 依次展示学生新增、参数校验、分页查询、条件查询、详情查询、局部更新和逻辑删除。
+
+## 一、答辩前检查
+
+### 1. 确认数据库和基础数据
+
+1. 确认 MySQL 已启动。
+2. 确认项目配置的数据库可以连接。
+3. 确认班级表中至少存在一条未删除的班级记录。
+4. 记住一个真实存在的班级 ID。下文示例使用 `class_id = 1`，如果数据库中不存在班级 1，请替换成实际班级 ID。
+
+`consultant_id` 在演示数据中使用 `null`，避免因为顾问外键不存在导致新增失败。
+
+### 2. 确认当前接口方法
+
+当前代码中的学生接口如下：
+
+| 功能 | 请求方法 | 地址 |
+| --- | --- | --- |
+| 新增学生 | `PUT` | `/students` |
+| 更新学生 | `POST` | `/students/{id}` |
+| 分页查询 | `GET` | `/students` |
+| 详情查询 | `GET` | `/students/{id}` |
+| 逻辑删除 | `DELETE` | `/students/{id}` |
+
+注意：常见 REST 规范通常使用 `POST` 新增、`PUT` 更新，但当前项目代码正好相反。答辩前如果修改了请求方法，需要同步调整本文档中的操作。
+
+### 3. 启动项目
+
+在项目根目录执行：
+
+```powershell
+python main.py
+```
+
+看到服务正常启动后，在浏览器打开：
+
+```text
+http://127.0.0.1:23333/docs
+```
+
+在 Swagger 页面找到“学生接口”。
+
+## 二、正式演示流程
+
+建议严格按照下面的顺序演示。每次操作时先展开接口，点击 **Try it out**，填写参数或请求体，再点击 **Execute**。
+
+## 步骤 1：演示新增参数校验
+
+展开：
+
+```text
+PUT /students
+```
+
+先输入一条性别不合法的数据：
+
+```json
+{
+  "student_name": "答辩演示学生",
+  "class_id": 1,
+  "consultant_id": null,
+  "native_place": "河南",
+  "graduation_school": "演示大学",
+  "major": "软件工程",
+  "enrollment_date": "2025-09-01",
+  "graduation_date": "2027-06-30",
+  "education": "本科",
+  "age": 22,
+  "gender": "未知"
+}
+```
+
+预期结果：HTTP 状态码为 `422`，提示 `gender` 只能是“男”或“女”。
+
+讲解词：
+
+> 请求进入接口之前会先经过 Pydantic 请求模型校验。性别字段使用 Literal 约束，只允许男或女，非法数据不会进入 DAO 层，也不会写入数据库。
+
+## 步骤 2：演示日期校验
+
+仍然使用新增接口，将毕业日期设置为早于入学日期：
+
+```json
+{
+  "student_name": "答辩演示学生",
+  "class_id": 1,
+  "consultant_id": null,
+  "native_place": "河南",
+  "graduation_school": "演示大学",
+  "major": "软件工程",
+  "enrollment_date": "2025-09-01",
+  "graduation_date": "2024-06-30",
+  "education": "本科",
+  "age": 22,
+  "gender": "男"
+}
+```
+
+预期结果：HTTP 状态码为 `422`，提示“毕业日期不能早于入学日期”。
+
+讲解词：
+
+> 除了单字段类型和范围校验，我还使用模型级校验器校验两个日期之间的业务关系。
+
+## 步骤 3：新增一名合法学生
+
+继续使用：
+
+```text
+PUT /students
+```
+
+输入以下合法数据：
+
+```json
+{
+  "student_name": "答辩演示学生",
+  "class_id": 1,
+  "consultant_id": null,
+  "native_place": "河南",
+  "graduation_school": "演示大学",
+  "major": "软件工程",
+  "enrollment_date": "2025-09-01",
+  "graduation_date": "2027-06-30",
+  "education": "本科",
+  "age": 22,
+  "gender": "男"
+}
+```
+
+这里故意不传 `student_no`。DAO 在插入并取得自增主键后，会自动生成类似 `STU0001` 的学生编号。
+
+预期响应：
+
+```json
+{
+  "code": 200,
+  "detail": "添加学生成功"
+}
+```
+
+讲解词：
+
+> 新增请求先由 StudentCreate 完成字段校验，再通过 model_dump 转成字典。DAO 创建 ORM 实例并执行 flush 获取自增 ID，如果没有手动传入学号，就根据 ID 自动生成学号，最后提交事务。
+
+## 步骤 4：分页查询并记录演示学生 ID
+
+展开：
+
+```text
+GET /students
+```
+
+填写：
+
+```text
+page = 1
+page_size = 5
+```
+
+其他查询条件暂时留空，然后执行。
+
+预期结果：
+
+- `code` 为 `200`；
+- `total` 表示未删除学生的总数；
+- `page` 为 `1`；
+- `page_size` 为 `5`；
+- `data` 最多返回 5 条；
+- 数据按照学生 ID 倒序排列，刚新增的学生通常在第一条。
+
+从返回结果中找到 `student_name` 为“答辩演示学生”的记录，并记下：
+
+```text
+id = ________
+student_no = ________
+```
+
+后续所有 `{id}` 都替换成这里记录的真实学生 ID。
+
+讲解词：
+
+> 查询时先添加 is_deleted 等于 0 的条件，确保逻辑删除的数据不可见；然后在分页之前调用 count 获取符合条件的总数，最后使用 offset 和 limit 完成分页。固定按 ID 倒序可以保证分页顺序稳定。
+
+分页计算公式：
+
+```text
+offset = (page - 1) * page_size
+```
+
+## 步骤 5：演示姓名模糊查询
+
+继续使用：
+
+```text
+GET /students
+```
+
+填写：
+
+```text
+student_name = 答辩
+page = 1
+page_size = 10
+```
+
+预期结果：只返回姓名中包含“答辩”的未删除学生。
+
+讲解词：
+
+> 查询参数都是可选的。前端传入姓名时，DAO 使用 LIKE 完成模糊查询；没有传入的条件不会拼接到 SQL 中。
+
+也可以补充展示以下任意一种查询：
+
+```text
+student_no = 上一步记录的学号
+```
+
+或者：
+
+```text
+class_id = 1
+```
+
+## 步骤 6：查询单个学生详情
+
+展开：
+
+```text
+GET /students/{id}
+```
+
+将 `id` 填写为步骤 4 记录的学生 ID，然后执行。
+
+预期响应结构：
+
+```json
+{
+  "code": 200,
+  "detail": "查询成功",
+  "data": {
+    "id": 1,
+    "student_no": "STU0001",
+    "student_name": "答辩演示学生",
+    "class_id": 1,
+    "consultant_id": null,
+    "native_place": "河南",
+    "graduation_school": "演示大学",
+    "major": "软件工程",
+    "enrollment_date": "2025-09-01",
+    "graduation_date": "2027-06-30",
+    "education": "本科",
+    "age": 22,
+    "gender": "男"
+  }
+}
+```
+
+实际的 `id` 和 `student_no` 以数据库返回为准。
+
+讲解词：
+
+> DAO 使用主键和 is_deleted 等于 0 两个条件查询。API 层手动组装返回字典，只暴露业务需要的字段，不返回 is_deleted、创建时间等内部字段。
+
+## 步骤 7：局部更新学生
+
+展开：
+
+```text
+POST /students/{id}
+```
+
+将 `id` 填写为步骤 4 记录的学生 ID，请求体只输入需要修改的字段：
+
+```json
+{
+  "age": 23,
+  "gender": "女"
+}
+```
+
+预期结果：返回“修改学生成功”，其他未传字段保持不变。
+
+讲解词：
+
+> 更新模型中的字段都是可选字段，接口通过 model_dump 的 exclude_unset 参数只提取前端实际传入的字段，DAO 再使用 setattr 循环完成局部更新。
+
+更新完成后，再执行一次：
+
+```text
+GET /students/{id}
+```
+
+确认：
+
+```text
+age = 23
+gender = 女
+```
+
+其余字段没有变化。
+
+## 步骤 8：演示更新参数校验
+
+再次调用：
+
+```text
+POST /students/{id}
+```
+
+输入：
+
+```json
+{
+  "age": 200,
+  "gender": "其他"
+}
+```
+
+预期结果：HTTP 状态码为 `422`。
+
+讲解词：
+
+> 年龄限制在 0 到 150 之间，性别限制为男或女。参数校验失败时，请求不会进入更新 DAO，因此数据库中的数据不会被修改。
+
+## 步骤 9：逻辑删除学生
+
+展开：
+
+```text
+DELETE /students/{id}
+```
+
+填写步骤 4 记录的学生 ID，然后执行。
+
+预期响应：
+
+```json
+{
+  "code": 200,
+  "detail": "删除学生成功"
+}
+```
+
+讲解词：
+
+> 删除操作不是物理删除，而是把 is_deleted 更新为 1。这样可以保留历史数据，同时所有正常查询都会通过 is_deleted 等于 0 将其过滤掉。
+
+## 步骤 10：验证逻辑删除
+
+删除后，再执行：
+
+```text
+GET /students/{id}
+```
+
+预期结果：HTTP 状态码为 `404`：
+
+```json
+{
+  "detail": "学生不存在"
+}
+```
+
+再执行学生列表查询或姓名模糊查询，也不应该看到刚才删除的学生。
+
+讲解词：
+
+> 数据库记录仍然存在，但详情查询和列表查询都统一增加了 is_deleted 等于 0 的条件，所以业务层已经无法查询到该记录。
+
+## 三、建议的答辩讲解顺序
+
+可以用下面这段话概括学生模块：
+
+> 学生模块采用 API、Schema、DAO 和 Model 分层。Schema 负责请求参数的类型、范围和业务规则校验；API 负责接收请求、处理 HTTP 状态码以及控制响应字段；DAO 负责数据库查询和事务处理；Model 负责学生表与字段的 ORM 映射。列表接口支持学号精确查询、姓名模糊查询、班级查询以及分页，并统一过滤逻辑删除数据。新增支持自动生成学生编号，修改支持局部更新，删除采用逻辑删除。
+
+## 四、常见提问与回答
+
+### 1. 为什么分页之前先执行 count？
+
+因为前端需要知道符合条件的总数据量。`count()` 必须在 `offset` 和 `limit` 之前执行，否则统计到的可能只是当前页的数据量。
+
+### 2. 为什么分页查询要排序？
+
+如果不指定排序，数据库每次返回数据的顺序不一定稳定，可能造成翻页时数据重复或遗漏。当前代码按照学生 ID 倒序排列。
+
+### 3. 为什么使用逻辑删除？
+
+逻辑删除能够保留历史数据，避免误删除后无法恢复。正常查询通过 `is_deleted == 0` 过滤已删除记录。
+
+### 4. 为什么列表和详情要手动组装字典？
+
+手动组装能够明确控制暴露给前端的字段，避免把 `is_deleted` 等数据库内部字段返回给用户。
+
+### 5. 为什么修改接口只更新部分字段？
+
+前端可能只修改年龄或手机号等个别字段。使用 `exclude_unset=True` 只获取实际传入的字段，再通过 `setattr` 更新，可以避免未传字段被错误覆盖。
+
+### 6. 为什么非法参数返回 422？
+
+FastAPI 会先调用 Pydantic 校验请求体。数据类型、字段范围或 Literal 约束不满足时，请求不会进入业务函数，而是直接返回 422。
+
+### 7. 为什么学生编号可以不传？
+
+学生记录执行 `flush()` 后可以取得数据库生成的自增主键，系统再根据主键生成学生编号，能够减少手工编号冲突。
+
+## 五、故障排查
+
+### 请求体报 JSON decode error
+
+检查以下问题：
+
+- 属性名和值必须使用英文双引号；
+- 最后一个字段后面不能有逗号；
+- JSON 中不能写注释；
+- 日期必须使用 `YYYY-MM-DD` 格式。
+
+合法示例：
+
+```json
+{
+  "age": 23,
+  "gender": "女"
+}
+```
+
+### 新增返回 500
+
+优先检查：
+
+1. MySQL 是否启动；
+2. 数据库连接配置是否正确；
+3. `class_id` 是否在班级表中真实存在；
+4. 手动填写的 `student_no` 是否与已有记录重复；
+5. 如果填写了 `consultant_id`，该顾问是否真实存在。
+
+### 查询详情返回 404
+
+检查：
+
+1. ID 是否填写正确；
+2. 该学生是否已经被逻辑删除；
+3. 是否误用了列表中的班级 ID 或顾问 ID。
+
+### Swagger 请求体只显示 `{}`
+
+检查 `StudentUpdate` 是否被错误地重复嵌套。正确写法应该只有一层：
+
+```python
+class StudentUpdate(BaseModel):
+    student_name: str | None = None
+    # 其他字段……
+```
+
+## 六、演示结束检查表
+
+- [ ] 服务可以正常启动；
+- [ ] Swagger 可以打开；
+- [ ] 已确认一个真实存在的班级 ID；
+- [ ] 性别非法数据返回 422；
+- [ ] 日期非法数据返回 422；
+- [ ] 合法学生新增成功；
+- [ ] 已从列表中记录新增学生 ID 和学号；
+- [ ] 分页和条件查询成功；
+- [ ] 详情查询不暴露内部字段；
+- [ ] 局部更新后未传字段保持不变；
+- [ ] 逻辑删除成功；
+- [ ] 删除后详情查询返回 404。
+

docs/模型与建表改动说明.md

@@ -0,0 +1,217 @@
+# 数据库模型与建表工具改动说明
+
+本次按照《沃林学生管理系统小组分工说明书 V1》修正模型定义，整理范围为 7 个 Model 文件和 1 个建表脚本。各模块继续使用 `core.database.Base`，保留原有 Python 类名和项目目录。
+
+## 一、改动总览
+
+| 模块 | 负责人 | 修改文件 | 模型类 | 最终表名 |
+|---|---|---|---|---|
+| 学生管理 | 李玉杰 | `models/student.py` | `Student` | `students` |
+| 班级管理 | 婷婷 | `models/class_model.py` | `Classes` | `classes` |
+| 老师管理 | 张义 | `models/teacher.py` | `Teacher` | `teachers` |
+| 班级老师关系 | 张义 | `models/class_teacher.py` | `ClassTeachers` | `class_teachers` |
+| 顾问管理 | 薄鑫 | `models/consultant.py` | `Consultant` | `consultants` |
+| 成绩管理 | 曾凯 | `models/score.py` | `Score` | `scores` |
+| 就业管理 | 南方宇 | `models/employment.py` | `Employment` | `employments` |
+| 公共建库建表工具 | 张昕浩 | `utils/create database.py` | — | 使用上述全部模型 |
+
+### 经确认保留的类型
+
+本次没有将所有主键统一为文档中的 `BIGINT`，成绩精度也按已确认的要求保留。
+
+| 项目 | 当前模型类型 |
+|---|---|
+| 学生、班级、老师、顾问、成绩表的 `id` | `Integer` |
+| 班级老师关系表、就业表的 `id` | `BigInteger` |
+| 各表关联其他表的外键字段 | `Integer`，与对应模型的主键一致 |
+| 成绩字段 `scores.score` | `DECIMAL(4,1)` |
+| 薪资字段 `employments.salary` | `DECIMAL(10,2)` |
+
+其中 `class_teachers.class_id`、`class_teachers.teacher_id`、`employments.student_id` 原为 `BigInteger`，经确认改为 `Integer`，解决 MySQL 要求外键与被引用主键类型一致的问题。
+
+## 二、公共字段调整
+
+以下规则落实在各个 Model 文件中，没有增加公共模型文件或额外继承层。
+
+| 字段 | 最终定义及作用 |
+|---|---|
+| `created_at` | `DATETIME`、不可为空；保留 ORM 创建时间默认值，增加数据库默认值 `CURRENT_TIMESTAMP` |
+| `updated_at` | `DATETIME`、不可为空；使用 `onupdate=datetime.now`，增加数据库默认值及 `ON UPDATE CURRENT_TIMESTAMP` |
+| `is_deleted` | MySQL `TINYINT`、不可为空；ORM 默认值和数据库默认值均为 `0` |
+
+原先误用 `sqlalchemy.dialects.mssql.TINYINT` 的老师、班级老师关系模型，改为从 `sqlalchemy.dialects.mysql` 导入。
+
+`is_deleted` 是逻辑删除标志。Model 中声明这个字段不会自动过滤查询；接口查询仍需添加 `is_deleted == 0`，删除业务记录应更新该标志。
+
+## 三、学生管理模块
+
+文件：`models/student.py`；负责人：李玉杰。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 表名 | `student_info_detail` | `students` |
+| 学生编号 | 唯一，但允许为空 | 唯一且 `nullable=False` |
+| 学生姓名 | 允许为空 | `nullable=False` |
+| 班级外键 | `foreign_key='class_info_detail.id'`，不是有效外键声明 | `ForeignKey('classes.id')`，并设为非空 |
+| 顾问外键 | `foreign_key='consultant_info_detail.id'`，不是有效外键声明 | `ForeignKey('consultants.id')`，继续允许为空 |
+| 毕业院校字段 | `graduation_school` | `graduate_school` |
+| 创建时间字段 | `create_at` | `created_at` |
+| 更新时间字段 | `update_at` | `updated_at` |
+| 逻辑删除 | `Integer`，允许为空 | MySQL `TINYINT`、非空、默认 `0` |
+
+时间字段按公共规则补齐数据库默认值及非空约束。学生主键、班级外键和顾问外键均保留 `Integer`。
+
+## 四、班级管理模块
+
+文件：`models/class_model.py`；负责人：婷婷。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 开课日期 `start_date` | 允许为空 | `nullable=False`，开课时间必填 |
+| 更新时间字段 | `update_at` | `updated_at` |
+| 备注长度 | `String(100)` | `String(255)` |
+| 逻辑删除 | `INTEGER` | MySQL `TINYINT`，补充数据库默认值 `0` |
+
+时间字段增加数据库默认值和数据库自动更新时间设置。保留表名 `classes`、类名 `Classes`、`Integer` 自增主键，以及班级编号唯一且非空的约束。
+
+## 五、老师管理模块
+
+文件：`models/teacher.py`；负责人：张义。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 表名 | `teachers_info_detail` | `teachers` |
+| 备注长度 | `VARCHAR(2550)` | `VARCHAR(255)` |
+| `TINYINT` 来源 | SQL Server 方言 | MySQL 方言 |
+| 更新时间 | 仅设置创建时的默认时间 | 补充 `onupdate=datetime.now` 和数据库自动更新时间 |
+
+创建时间增加数据库默认值，逻辑删除增加数据库默认值 `0`。保留 `Integer` 自增主键和老师编号唯一约束。
+
+## 六、班级老师关系模块
+
+文件：`models/class_teacher.py`；负责人：张义。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 表名 | `class_teachers_info_detail` | `class_teachers` |
+| 班级外键目标 | `ForeignKey('class_id')` | `ForeignKey('classes.id')` |
+| 老师外键目标 | `ForeignKey('teacher_id')` | `ForeignKey('teachers.id')` |
+| 两个外键字段类型 | `BigInteger` | `Integer`，与班级、老师模型主键匹配 |
+| 联合唯一约束 | 未设置 | `(class_id, teacher_id, role)` 联合唯一 |
+| 联合唯一约束名称 | — | `uk_class_teacher_role` |
+| 时间默认值 | `datetime.now()`，导入模型时就求值 | `datetime.now`，插入记录时再求值 |
+| `TINYINT` 来源 | SQL Server 方言 | MySQL 方言 |
+
+补齐时间及逻辑删除的数据库默认值，并为更新时间增加自动更新设置。关系表自身的 `id` 保留 `BigInteger`，类名保留 `ClassTeachers`。
+
+联合唯一约束防止同一个老师以同一个角色被重复分配到同一个班级。
+
+## 七、顾问管理模块
+
+文件：`models/consultant.py`；负责人：薄鑫。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 联系电话长度 | `String(11)` | `String(20)` |
+| 逻辑删除类型 | `Integer` | MySQL `TINYINT` |
+| 数据库默认值 | 未声明 | 补充创建时间、更新时间和逻辑删除默认值 |
+
+保留表名 `consultants`、`Integer` 自增主键、顾问编号唯一且非空的约束，以及其余业务字段。
+
+## 八、成绩管理模块
+
+文件：`models/score.py`；负责人：曾凯。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 表名 | `score_info_detail` | `scores` |
+| 学生外键目标 | `ForeignKey('student.id')` | `ForeignKey('students.id')` |
+| 成绩是否必填 | 允许为空 | `nullable=False` |
+| 联合唯一约束名称 | `uk_student_exam_seq` | `uk_scores_student_exam` |
+| 备注长度 | `String(225)` | `String(255)` |
+| 逻辑删除 | `Integer`，允许为空 | MySQL `TINYINT`、非空、默认 `0` |
+
+创建时间和更新时间补齐非空约束、数据库默认值及自动更新设置；修正注释，明确联合唯一约束是“学生 ID + 考核序次”。
+
+保留 `Integer` 主键及学生外键，成绩精度保留 `DECIMAL(4,1)`，保留成绩范围 `0～100` 的检查约束。一个学生同一次考核只能有一条成绩。
+
+## 九、就业管理模块
+
+文件：`models/employment.py`；负责人：南方宇。
+
+| 修改项 | 修改前 | 修改后 |
+|---|---|---|
+| 学生外键类型 | `BigInteger` | `Integer`，与学生模型主键匹配 |
+| 学生就业唯一约束 | 未设置 | `student_id` 增加 `unique=True` |
+| 就业状态长度 | `String(50)` | `String(30)` |
+| 就业状态是否必填 | 允许为空 | `nullable=False` |
+| 逻辑删除 | `SmallInteger`，允许为空 | MySQL `TINYINT`、非空、默认 `0` |
+
+创建时间和更新时间补齐非空约束、数据库默认值及自动更新设置。修正薪资字段注释：`DECIMAL` 是定点小数。
+
+保留表名 `employments`、`BigInteger` 自增主键、`ForeignKey('students.id')`，以及薪资精度 `DECIMAL(10,2)`。学生外键唯一约束确保每个学生最多对应一条就业信息。
+
+## 十、公共建库建表工具
+
+文件：`utils/create database.py`；负责人：张昕浩。文件名中包含一个空格。
+
+脚本执行流程：
+
+1. 将项目根目录加入当前进程的导入路径，使直接运行此文件时也能导入 `core` 和 `models`。
+2. 导入全部 7 个模型，将模型表注册到公共 `Base.metadata`。
+3. 检查整数外键与被引用主键的类型是否一致；不一致时列出具体字段并以失败状态退出。
+4. 从现有 `core.database.engine` 读取连接设置，先连接不指定数据库的 MySQL 服务。
+5. 创建缺失的数据库，字符集为 `utf8mb4`、排序规则为 `utf8mb4_unicode_ci`；当前配置库名为 `student_manager`。
+6. 调用 `Base.metadata.create_all(bind=engine)` 创建缺失的表。
+7. 查询实际表名，确认全部模型对应的表均存在。
+8. 释放数据库连接池；发生数据库或检查错误时输出原因，并返回非零退出码。
+
+在项目根目录运行：
+
+```powershell
+python "utils/create database.py"
+```
+
+本机已验证使用的解释器命令：
+
+```powershell
+& 'D:\conda\envs\ai0720\python.exe' -B -X utf8 '.\utils\create database.py'
+```
+
+脚本只创建缺失的库和表，不清空数据、不删除表，也不自动修改已有表结构。
+
+## 十一、验证结果及范围
+
+完成三处外键类型修正后，脚本退出码为 `0`，输出如下：
+
+```text
+数据库已就绪：student_manager
+已导入的模型表： classes, teachers, consultants, students, class_teachers, scores, employments
+建表检查通过：全部模型对应的表均已存在。
+```
+
+已经完成的检查包括：
+
+- 7 个模型可以导入，6 个外键目标均能解析。
+- 外键与被引用主键在模型中的类型检查通过。
+- 7 张表的 MySQL 建表 SQL 可以编译。
+- 字段名、非空设置、字符串长度与本次对照结果一致。
+- 班级老师关系、成绩和就业的必要唯一约束已在模型中定义。
+- 7 个模型可以读取现有数据库中的对应表。
+- 文件差异格式检查通过。
+
+本次执行针对已有的 `student_manager` 数据库。`create_all()` 会跳过已有表，因此此结果不等同于已经在全新空库中完成端到端创建测试，也不表示现有数据库已经迁移成当前模型定义。
+
+现有库中的相关主外键仍为原来的 `BIGINT`，成绩列仍为原来的 `DECIMAL(5,2)`；本次没有执行 `ALTER TABLE`，模型里经确认保留的 `Integer` 和 `DECIMAL(4,1)` 不会自动改变这些实库类型。
+
+## 十二、后续接口联调事项
+
+以下配套代码不在本次修改范围内，需要模块负责人继续核对：
+
+| 位置 | 需要核对的内容 |
+|---|---|
+| `schemas/class_schema.py` 的 `ClassCreate` | 当前缺少 `start_date`，而模型规定开课日期必填 |
+| `schemas/class_schema.py` 的 `ClassUpdate` | 当前仍使用 `update_at`，模型字段已统一为 `updated_at` |
+| 学生新增及业务编号生成逻辑 | `student_no` 已设为非空；先以空编号执行 `flush()` 再生成编号会违反非空约束，需要与编号生成方案协调 |
+
+本次验证覆盖模型和建表工具，尚未完成上述业务接口的联调验证。

magic_llm/llm_func.py

@@ -0,0 +1,62 @@
+from openai import OpenAI
+from pathlib import Path
+from models.class_model import Classes
+from models.employment import Employment
+from models.student import Student
+from models.class_teacher import ClassTeachers
+from models.consultant import Consultant
+from models.score import Score
+from models.teacher import Teacher
+from sqlalchemy import func
+
+def llm_func(input_user):
+
+    client = OpenAI(
+    api_key="sk-2e7da09d2ef1432f96af95114824e6b5",
+    base_url="https://api.deepseek.com"
+    )
+
+    prom_path = Path(__file__).parent / "prom.txt"   #拼接路径
+    context = prom_path.read_text(encoding="utf-8")
+
+
+
+    # 2. 调用大模型
+
+    response = client.chat.completions.create(
+        model="deepseek-flash",
+        messages=[
+            {
+                "role": "system",
+                "content": context
+            },
+            {
+                "role": "user",
+                "content": input_user
+            }
+        ]
+    )
+
+    # 3. 获取AI回复
+    code = response.choices[0].message.content
+    print("====== LLM生成代码 ======")
+    print(code)
+    print("========================")
+
+    env = {
+        "Student": Student,
+        "Classes": Classes,
+        "Employment": Employment,
+        "ClassTeachers": ClassTeachers,
+        "Consultant": Consultant,
+        "Score": Score,
+        "Teacher": Teacher,
+        "func": func
+    }
+
+    namespace={}
+    exec(code, env,namespace)
+
+    execute_func = namespace["execute"]
+    return execute_func,code
+

magic_llm/prom.txt

@@ -0,0 +1,371 @@
+你是一个 Python + SQLAlchemy 动态代码生成器。
+
+下面是当前学生管理系统所有 SQLAlchemy 数据库模型代码：
+
+----------------
+{base_code}
+----------------
+
+请根据数据库模型理解：
+- 有哪些数据表
+- 每个 ORM 模型的 Python 类名
+- 每个模型有哪些字段
+- 主键和外键关系
+- 模型之间应该如何进行 JOIN
+
+用户需求：
+
+{question}
+
+你需要根据用户需求生成能够直接运行的 Python 函数。
+
+回复必须严格遵守下面格式：
+
+def execute(db):
+    # 查询或数据库操作代码
+    ...
+    return result
+
+你已经获得完整的 SQLAlchemy ORM 模型代码。
+
+必须直接使用模型代码中已经定义的 ORM 类和字段。
+
+例如模型中存在 Student、Classes、Teacher、Employment，
+则直接使用这些类进行查询。
+
+如果条件不够无法查询则返回条件不够无法查询并说明原因。
+
+
+规则：
+
+1. 函数名称必须固定为 execute。
+2. 函数只能接收参数 db。
+3. db 是已经创建好的 SQLAlchemy Session。
+4. 使用现有 ORM Model 完成操作。
+5. 不要重新定义数据库模型。
+6. 不要创建数据库连接。
+7. 不要创建 Session。
+8. 不要生成 FastAPI 路由。
+9. 可以根据需求自由使用 query、filter、join、group_by、having、func、子查询等 SQLAlchemy 功能。
+10. 用户要求修改、增加或删除数据时可以调用 commit。
+11. execute 必须 return 最终结果。
+12. 尽量将查询结果转换为 dict、list、str、int、float 等容易 JSON 序列化的数据。
+13. 不要解释代码。
+14. 不要返回 Markdown。
+15. 不要使用 ```python。
+16. 不要使用 ```。
+17. 除 execute 函数源码之外，不要返回任何其他文字。
+
+
+
+
+禁止：
+1. 动态扫描 mapper
+2. 使用 mapperlib
+3. 使用 Base.registry 查找模型
+4. 根据字段名称猜测字段
+5. 根据表名猜测 ORM 类
+6. 动态寻找 relationship
+7. 使用 SQLAlchemy 内部 API
+
+你必须根据提供的模型代码直接确定：
+- ORM 类
+- 字段
+- 外键关系
+- JOIN 条件
+
+
+
+最终回复示例：
+
+def execute(db):
+    result = db.query(Student).all()
+    return [
+        {
+            "id": item.id,
+            "name": item.student_name
+        }
+        for item in result
+    ]
+
+以下为建表语句，所有的查询操作都当围绕如下表进行
+
+class Classes( Base ):              # 在python里的名字
+    __tablename__ = 'class_info_detail'       # 在数据库中表的名字
+    #————创建班级"主键"的字段名————
+    id = Column( Integer                 # 声明字段的数据类型是"整数"
+               , primary_key = True      # 声明是"主键"
+               , autoincrement = True    # 声明是"自增主键"
+               , nullable = False         # 声明是"非空"
+               )
+    # ————创建班级"编号"的字段名————
+    class_no = Column( String(50)         # 声明字段的数据类型是"字符串,且最长为50个字符"
+                     , unique = True      # 声明是"唯一约束"
+                     , nullable = False    # 声明是"非空"
+                     )
+    # ————创建"班级名称"的字段名————
+    class_name = Column( String(100)      # 声明字段的数据类型是"字符串,且最长为100个字符"
+                       , nullable = False  # 声明是"非空"
+                       )
+    # ————创建班级"开课时间"的字段名————
+    start_date = Column( DATE             # 声明是字段数据类型是日期
+                       , nullable = False  # 开课时间必填
+                       )
+    # ————创建班级"结课时间"的字段名————
+    end_date = Column( DATE               # 声明是字段数据类型是'日期'
+                     , nullable = True     # 声明是"可为空"
+                     )
+    # ————创建班级"创建时间"的字段名————
+    created_at = Column( DATETIME         # 声明是字段数据类型是"日期时间"
+                       , default=datetime.now  # 声明是创建的默认值就是"当前时间"
+                       , server_default=text("CURRENT_TIMESTAMP")
+                       , nullable = False         # 声明是"非空"
+                       )
+    # ————创建班级"更新时间"的字段名————
+    update_at = Column( DATETIME         # 声明是字段数据类型是"日期时间"
+                       , default=datetime.now  #声明是第一次更新的时间就是第一次创建的时间一致
+                       , onupdate=datetime.now   # 声明"最后修改的时间"
+                       , server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
+                       , nullable = False         # 声明是"非空"
+                       )
+    # ————创建班级"备注信息"的字段名————
+    remark = Column( String(255)           # 声明是字段数据类型是"字符串"
+                   , nullable = True        # 声明是"可以为空"
+                   )
+    # ————创建班级"逻辑删除"的字段名————
+    is_deleted = Column( TINYINT           # 逻辑删除标记
+                       , default = 0       # 声明默认值是"0，未删除"
+                       , server_default = text("0")
+                       , nullable = False  # 声明是"非空"
+                       )
+
+#班级老师关系表 class_teachers_info_detail 中间表 ORM 模型完整定义
+#字段包括id,class_id,teacher_id,role,created_at,updated_at,is_deleted
+class ClassTeachers(Base):
+    __tablename__ = "class_teachers_info_detail"
+    id = Column(
+         Integer
+        ,primary_key=True
+        ,autoincrement=True
+        ,comment='关系')
+    class_id = Column(
+         Integer
+        ,ForeignKey('class_info_detail.id')
+        ,nullable=False
+        ,comment='关联 class_id'
+    )
+    teacher_id = Column(
+         Integer
+        ,ForeignKey("teacher_info_detail.id")
+        ,nullable=False
+        ,comment='关联 teacher_id'
+    )
+    role = Column(
+         VARCHAR(30)
+        ,nullable=False
+        ,comment='老师在班级中的角色：head_teacher班主任 / lecturer授课老师 / assistant助教'
+    )
+    created_at = Column(
+         DateTime
+        ,nullable=False
+        ,default=datetime.now()
+        ,comment='创建时间'
+    )
+    updated_at = Column(
+         DateTime
+        ,nullable=False
+        ,default=datetime.now()
+        ,comment='更新时间'
+    )
+    is_deleted = Column(
+        TINYINT
+        ,nullable=False
+        ,default=0
+        ,comment='逻辑删除'
+    )
+
+class Consultant(Base):
+    __tablename__ = "consultant_info_detail"
+
+    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
+    consultant_no = Column(String(50), unique=True, nullable=False, comment="顾问编号")
+    consultant_name = Column(String(50), nullable=False, comment="顾问姓名")
+    phone = Column(String(20), nullable=True, comment="联系电话")
+    email = Column(String(100), nullable=True, comment="邮箱")
+    remark = Column(String(255), nullable=True, comment="备注")
+
+    created_at = Column(DateTime, default=datetime.now, server_default=text("CURRENT_TIMESTAMP"), nullable=False, comment="创建时间")
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"), nullable=False, comment="更新时间")
+    is_deleted = Column(TINYINT, default=0, server_default=text("0"), nullable=False, comment="逻辑删除：0正常，1删除")
+
+
+class Employment(Base):
+    __tablename__ = "employment_info_detail"                              # 实际数据库的表名字
+    id = Column(Integer, primary_key=True                   # 主键
+                , autoincrement=True                           # 声明是自增主键
+                ,comment="就业信息主键id")
+    student_id = Column(Integer, ForeignKey("student_info_detail.id")  # 外键 -> students.id
+                        , nullable=False                       # 不允许为null
+                        ,comment="关联学生id")
+    employment_status = Column(String(50)
+                               , default="not_started"
+                               ,comment="就业状态:not_started/job_hunting/offered/employed")
+    employment_open_date = Column(Date
+                                  ,comment="就业开放时间")
+    offer_date = Column(Date
+                        ,comment="offer下发时间")
+    company_name = Column(String(100)
+                          , comment="就业公司名称")
+    salary = Column(DECIMAL(10, 2)                      # 高精度浮点数薪资,最多 10 位数字，小数占 2 位
+                    , comment="就业薪资")
+    remark = Column(String(255)
+                    ,default=None
+                    , comment="备注信息")
+    created_at = Column(DateTime
+                        , default=datetime.now
+                        , comment="创建时间")
+    updated_at = Column(DateTime
+                        , default=datetime.now
+                        , onupdate=datetime.now
+                        ,comment="更新时间")
+    is_deleted = Column(SmallInteger
+                        ,default=0
+                        ,comment="逻辑删除：0正常，1删除")
+
+class Score(Base):
+    __tablename__ = "score_info_detail"
+    id = Column(Integer
+                , primary_key=True
+                ,autoincrement=True
+                ,comment="成绩表序号，自增主键"
+                )
+    student_id = Column(Integer
+                        ,ForeignKey("student_info_detail.id")
+                        ,nullable=False
+                        ,comment="学生学号"
+                        )
+    score = Column(DECIMAL(4,1)
+                   ,CheckConstraint("score between 0 and 100")
+                   )
+    exam_seq= Column(Integer
+                     , nullable=False
+                     ,comment="考试序次")
+    __table_args__ = (
+        UniqueConstraint("student_id"
+                         , "exam_seq"
+                         , name="uk_student_exam_seq"),
+    )#学生id和学生姓名应为联合唯一，即一个学生一次考试只能有一个分数
+    exam_date=Column(Date
+                     ,default=date.today
+                     ,comment="考试日期"
+                     )
+    created_at=Column(DateTime
+                      ,default=datetime.now
+                      ,comment="创建时间"
+                      )
+    updated_at=Column(DateTime
+                      ,default=datetime.now
+                      ,onupdate=datetime.now
+                      ,comment="更新时间"
+                      )
+    remark=Column(String(225)
+                  ,comment="备注说明"
+                  )
+    is_deleted=Column(Integer
+                      ,default=0
+                      ,comment="逻辑删除标记：未删除0，已删除1"
+                      )
+
+class Student(Base):
+    __tablename__ = 'student_info_detail'
+    id = Column(Integer
+                , primary_key=True
+                , autoincrement=True
+                , comment = '学生编号，自增主键'
+                )
+    student_no = Column(VARCHAR(50)
+                        ,nullable = True
+                        ,unique = True)
+    student_name = Column(VARCHAR(50))
+    class_id = Column(Integer
+                      ,ForeignKey('class_info_detail.id')
+                      )#外键约束 班级表的主键id，存在这个班级，学生表才可以输入
+    consultant_id = Column(Integer
+                           , ForeignKey('consultant_info_detail.id')
+                           ,nullable = True
+                           )#外键约束 顾问表的主键id，存在这个顾问，才可以写入，允许为空
+    native_place = Column(VARCHAR(100)
+                          ,nullable = True)
+    graduation_school = Column(VARCHAR(100)
+                               ,nullable = True)
+    major = Column(VARCHAR(100)
+                   ,nullable = True)
+    enrollment_date = Column(Date
+                             ,nullable = False)#入学时间必填
+    graduation_date = Column(Date,
+                             nullable = True)#毕业时间可以为空
+    education = Column(VARCHAR(50)
+                       ,nullable = True)#学历可以为空
+    age = Column(Integer
+                 ,nullable = False)
+    gender = Column(VARCHAR(10)
+                    ,nullable = False)
+    create_at = Column(DATETIME
+                       ,default = datetime.now)
+    update_at = Column(DATETIME
+                       ,default = datetime.now
+                       ,onupdate = datetime.now)
+    is_deleted = Column(Integer
+                        ,default = 0)#逻辑删除，默认为0，为1则表示已删除
+
+class Teacher(Base):
+    __tablename__ = 'teacher_info_detail'
+    id = Column(
+         Integer
+        , primary_key=True
+        ,autoincrement=True
+        ,comment='老师主键')
+    teacher_no = Column(
+        VARCHAR(50)
+        ,nullable=False
+        ,unique=True
+        ,comment='老师编号'
+    )
+    teacher_name = Column(
+        VARCHAR(50)
+        ,nullable=False
+        ,comment='老师名字'
+    )
+    phone = Column(
+        VARCHAR(20)
+        ,nullable=True
+        ,comment='老师电话'
+    )
+    email = Column(
+        VARCHAR(100)
+        ,nullable=True
+        ,comment='邮箱'
+    )
+    remark = Column(
+        VARCHAR(2550)
+        ,nullable=True
+        ,comment='备注'
+    )
+    created_at = Column(
+        DateTime
+        ,nullable=False
+        ,default=datetime.now
+        ,comment='创建时间'
+    )
+    updated_at = Column(
+        DateTime
+        ,nullable=False
+        ,default=datetime.now
+        ,comment='更新时间'
+    )
+    is_deleted = Column(
+        TINYINT
+        ,nullable=False
+        ,default=0
+        ,comment='逻辑删除'
+    )'''

main.py

@@ -4,28 +4,37 @@ from middleware import log_middleware
 from api.statistics import statistics_router
 import uvicorn
 from api.student import student_router
-app = FastAPI()
+from api.teacher import router as teacher_router,class_teacher_router
+from api.magic import magic_router
+
+app = FastAPI(title='学生管理系统')
 app.middleware("http")(log_middleware)
+app.include_router(magic_router)
 
 #-------------朱婷婷--------------
 from api.class_api import classes_router
 app.include_router(classes_router,tags=['班级接口'],prefix="/classes")
 
 #-------------李玉杰--------------
-app.include_router(student_router)
+app.include_router(student_router,tags=['学生接口'],prefix="/students")
 #-------------张义---------------
-
+app.include_router(teacher_router,tags=['教师接口'],prefix="/teachers")
+app.include_router(class_teacher_router,tags=['教师班级关系接口'],prefix="/class_teacher")
 #-------------薄鑫---------------
-
+from api import consultant
+app.include_router(consultant.router)
 #-------------张昕浩---------------
 app.include_router(example_router)
+app.include_router(magic_router)
 app.include_router(statistics_router, prefix="/statistics")
 
 #-------------曾凯---------------
-
+from api.score import scores_router
+app.include_router(scores_router, tags=['成绩接口'])
 #-------------南方宇---------------
-
+from api.employment import employment_router
+app.include_router(employment_router, prefix="/employment")
 #-----------主程序----------------
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=23333)
+    uvicorn.run(app, host="0.0.0.0", port=23333)

models/__init__.py

@@ -1 +1,7 @@
-
+from .class_model import Classes
+from .class_teacher import ClassTeachers
+from .consultant import Consultant
+from .employment import Employment
+from .score import Score
+from .student import Student
+from .teacher import Teacher

models/class_model.py

@@ -1,9 +1,11 @@
+# 班级model模块
 from sqlalchemy import *           # 导入sqlalchemy模块下所有的类，以便下面创建班级表模型和声明表的字段
 from datetime import datetime      # 导入datetime模块下的datetime类
 from core.database import Base     # 从core软件包下的database模块导入Base
+from sqlalchemy.dialects.mysql import TINYINT
 
 class Classes( Base ):              # 在python里的名字
-    __tablename__ = 'classes'       # 在数据库中表的名字
+    __tablename__ = 'class_info_detail'    # 在数据库中表的名字
     #————创建班级"主键"的字段名————
     id = Column( Integer                 # 声明字段的数据类型是"整数"
                , primary_key = True      # 声明是"主键"
@@ -21,7 +23,7 @@ class Classes( Base ):              # 在python里的名字
                        )
     # ————创建班级"开课时间"的字段名————
     start_date = Column( DATE             # 声明是字段数据类型是日期
-                       , nullable = True   # 声明是'可为空'
+                       , nullable = False  # 开课时间必填
                        )
     # ————创建班级"结课时间"的字段名————
     end_date = Column( DATE               # 声明是字段数据类型是'日期'
@@ -30,20 +32,23 @@ class Classes( Base ):              # 在python里的名字
     # ————创建班级"创建时间"的字段名————
     created_at = Column( DATETIME         # 声明是字段数据类型是"日期时间"
                        , default=datetime.now  # 声明是创建的默认值就是"当前时间"
+                       , server_default=text("CURRENT_TIMESTAMP")
                        , nullable = False         # 声明是"非空"
                        )
     # ————创建班级"更新时间"的字段名————
     update_at = Column( DATETIME         # 声明是字段数据类型是"日期时间"
                        , default=datetime.now  #声明是第一次更新的时间就是第一次创建的时间一致
                        , onupdate=datetime.now   # 声明"最后修改的时间"
+                       , server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
                        , nullable = False         # 声明是"非空"
                        )
     # ————创建班级"备注信息"的字段名————
-    remark = Column( String(100)           # 声明是字段数据类型是"字符串"
+    remark = Column( String(255)           # 声明是字段数据类型是"字符串"
                    , nullable = True        # 声明是"可以为空"
                    )
     # ————创建班级"逻辑删除"的字段名————
-    is_deleted = Column( INTEGER           # 声明是字段数据类型是"数字"
+    is_deleted = Column( TINYINT           # 逻辑删除标记
                        , default = 0       # 声明默认值是"0，未删除"
+                       , server_default = text("0")
                        , nullable = False  # 声明是"非空"
-                       )
+                       )

models/class_teacher.py

@@ -12,19 +12,19 @@ from datetime import datetime
 class ClassTeachers(Base):
     __tablename__ = "class_teachers_info_detail"
     id = Column(
-         BigInteger
+         Integer
         ,primary_key=True
         ,autoincrement=True
         ,comment='关系')
     class_id = Column(
-         BigInteger
-        ,ForeignKey('class_id')
+         Integer
+        ,ForeignKey('class_info_detail.id')
         ,nullable=False
         ,comment='关联 class_id'
     )
     teacher_id = Column(
-         BigInteger
-        ,ForeignKey('teacher_id')
+         Integer
+        ,ForeignKey("teacher_info_detail.id")
         ,nullable=False
         ,comment='关联 teacher_id'
     )
@@ -50,4 +50,4 @@ class ClassTeachers(Base):
         ,nullable=False
         ,default=0
         ,comment='逻辑删除'
-    )
+    )

models/consultant.py

@@ -1,17 +1,18 @@
 
 from sqlalchemy import *
+from sqlalchemy.dialects.mysql import TINYINT
 from datetime import datetime
 from core.database import Base
 class Consultant(Base):
-    __tablename__ = "consultants"
+    __tablename__ = "consultant_info_detail"
 
     id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
     consultant_no = Column(String(50), unique=True, nullable=False, comment="顾问编号")
     consultant_name = Column(String(50), nullable=False, comment="顾问姓名")
-    phone = Column(String(11), nullable=True, comment="联系电话")
+    phone = Column(String(20), nullable=True, comment="联系电话")
     email = Column(String(100), nullable=True, comment="邮箱")
     remark = Column(String(255), nullable=True, comment="备注")
 
-    created_at = Column(DateTime, default=datetime.now, nullable=False, comment="创建时间")
-    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment="更新时间")
-    is_deleted = Column(Integer, default=0, nullable=False, comment="逻辑删除：0正常，1删除")
+    created_at = Column(DateTime, default=datetime.now, server_default=text("CURRENT_TIMESTAMP"), nullable=False, comment="创建时间")
+    updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now, server_default=text("CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"), nullable=False, comment="更新时间")
+    is_deleted = Column(TINYINT, default=0, server_default=text("0"), nullable=False, comment="逻辑删除：0正常，1删除")

models/employment.py

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

models/score.py

@@ -9,7 +9,7 @@ class Score(Base):
                 ,comment="成绩表序号，自增主键"
                 )
     student_id = Column(Integer
-                        ,ForeignKey("student.id")
+                        ,ForeignKey("student_info_detail.id")
                         ,nullable=False
                         ,comment="学生学号"
                         )

models/student.py

@@ -10,14 +10,15 @@ class Student(Base):
                 , comment = '学生编号，自增主键'
                 )
     student_no = Column(VARCHAR(50)
-                        , unique = True)
+                        ,nullable = True
+                        ,unique = True)
     student_name = Column(VARCHAR(50))
     class_id = Column(Integer
-                      ,foreign_key = 'class_info_detail.id'
+                      ,ForeignKey('class_info_detail.id')
                       )#外键约束 班级表的主键id，存在这个班级，学生表才可以输入
     consultant_id = Column(Integer
+                           , ForeignKey('consultant_info_detail.id')
                            ,nullable = True
-                           ,foreign_key = 'consultant_info_detail.id'
                            )#外键约束 顾问表的主键id，存在这个顾问，才可以写入，允许为空
     native_place = Column(VARCHAR(100)
                           ,nullable = True)

models/teacher.py

@@ -5,11 +5,10 @@ from sqlalchemy.dialects.mssql import TINYINT
 from core.database import Base
 from datetime import datetime
 
-
 # teachers 老师表 ORM 模型
 #字段包括id,teacher_no,teacher_name,phone,email,remark,created_at,updated_at,is_deleted
 class Teacher(Base):
-    __tablename__ = 'teachers_info_detail'
+    __tablename__ = 'teacher_info_detail'
     id = Column(
          Integer
         , primary_key=True

requirements.txt

@@ -3,3 +3,5 @@ uvicorn==0.40.0
 SQLAlchemy==2.0.49
 PyMySQL==1.1.2
 pydantic==2.13.3
+openai==2.30.0
+python-dotenv==1.2.2

schemas/class_schema.py

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

schemas/consultant.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+from datetime import datetime
+from typing import Optional
+
+
+# 新增顾问 请求体
+class ConsultantCreate(BaseModel):
+    consultant_no: str
+    consultant_name: str
+    phone: Optional[str] = None
+    email: Optional[str] = None
+    remark: Optional[str] = None
+
+
+# 修改顾问 请求体
+class ConsultantUpdate(BaseModel):
+    consultant_name: Optional[str] = None
+    phone: Optional[str] = None
+    email: Optional[str] = None
+    remark: Optional[str] = None
+
+
+# 返回模型
+class ConsultantResponse(BaseModel):
+    id: int
+    consultant_no: str
+    consultant_name: str
+    phone: Optional[str]
+    email: Optional[str]
+    remark: Optional[str]
+    created_at: datetime
+    updated_at: datetime
+

schemas/employment.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, Field
+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="就业状态,选填")
+    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="就业公司名称，选填")
+    salary: Decimal | None = Field(None, ge=0, description="就业薪资，不能负数，选填")
+    remark: str | None = Field(None, max_length=255, description="备注，选填")
+
+
+class EmploymentUpdate(BaseModel):
+    """修改就业信息 请求体 Schema：全部字段可选，只传要修改的字段"""
+    employment_status: str | None = Field(None, description="就业状态")
+    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="就业公司名称")
+    salary: Decimal | None = Field(None, ge=0, description="就业薪资")
+    remark: str | None = Field(None, max_length=255, description="备注")
+
+
+class EmploymentResponse(BaseModel):
+    """就业信息返回响应体Schema，接口返回给前端的数据结构"""
+    id: int
+    student_id: int
+    employment_status: str
+    employment_open_date: date | None
+    offer_date: date | None
+    company_name: str | None
+    salary: Decimal | None
+    remark: str | None
+    created_at: datetime | None
+    updated_at: datetime | None

schemas/score.py

@@ -0,0 +1,36 @@
+from pydantic import BaseModel, Field
+from datetime import date, datetime
+from typing import Optional, List
+from decimal import Decimal
+
+
+class ScoreCreate(BaseModel):
+    student_id: int
+    exam_seq: int
+    score: Decimal = Field(ge=0, le=100, description="分数0‑100")
+    exam_date: Optional[date] = None
+    remark: Optional[str] = None
+
+
+class ScoreUpdate(BaseModel):
+    score: Optional[Decimal] = Field(None, ge=0, le=100)
+    exam_seq: Optional[int] = None
+    exam_date: Optional[date] = None
+    remark: Optional[str] = None
+
+
+class ScoreItem(BaseModel):
+    id: int
+    student_id: int
+    score: Decimal
+    exam_seq: int
+    exam_date: Optional[date]
+    remark: Optional[str]
+    created_at: Optional[datetime]
+    updated_at: Optional[datetime]
+    is_deleted: int
+
+
+class ScorePageResp(BaseModel):
+    total: int
+    data: List[ScoreItem]

schemas/student.py

@@ -1,18 +1,47 @@
-from pydantic import BaseModel
 from datetime import date
+from enum import Enum
 
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing import Literal
+
+#新建学生请求体
 class StudentCreate(BaseModel):
-    student_no: str|None = None
-    student_name: str
-    class_id: int
-    consultant_id: int | None = None
-    native_place: str | None = None
-    graduate_school: str | None = None
-    major: str | None = None
+    student_no: str | None = Field(default=None, min_length=1, max_length=50)
+    student_name: str = Field(min_length=1, max_length=50)
+    class_id: int = Field(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
     graduation_date: date | None = None
-    education: str | None = None
-    age: int
-    gender: str
+    education: str | None = Field(default=None, max_length=50)
+    age: int = Field(ge=0, le=150)
+    gender: Literal["男", "女"]
 
+    @model_validator(mode="after")
+    def check_dates(self):
+        # 3. 新增时两个日期都已确定，可以直接校验先后顺序。
+        if self.graduation_date and self.graduation_date < self.enrollment_date:
+            raise ValueError("毕业日期不能早于入学日期")
+        return self
 
+#更新学生请求体
+class StudentUpdate(BaseModel):
+    # 全部设为可选，前端只传需要修改的字段
+        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
+
+class Gender(str,Enum):
+    g1 = '男'
+    g2 = '女'

schemas/teacher.py

@@ -1,10 +1,16 @@
 from pydantic import BaseModel
 from typing import Optional
 from datetime import datetime
+
+from sqlalchemy import BigInteger
+from sqlalchemy.dialects.mssql import TINYINT
+from sqlalchemy.dialects.mysql import VARCHAR
+
+
 #===============老师表===================
 #===============请求体模型================
 class TeacherCreate(BaseModel):
-    teacher_no: Optional[str] = None
+    teacher_no: Optional[int] = None
     teacher_name: Optional[str] = None
     email: Optional[str] = None
     phone: Optional[str] = None
@@ -17,3 +23,36 @@ class TeacherUpdate(BaseModel):
     phone: Optional[str] = None
     remark: Optional[str] = None
 
+#================响应体==================
+class TeacherOut(BaseModel):
+    id: int
+    teacher_no: str
+    teacher_name: str
+    phone: Optional[str]
+    email: Optional[str]
+    remark: Optional[str]
+    created_at: datetime
+    updated_at: datetime
+    is_deleted: int
+#`orm_mode = True` 是 Pydantic v1 的配置项。开启之后，Pydantic 可以直接读取 SQLAlchemy
+# 查询得到的 ORM 对象的属性，自动映射生成接口响应 JSON，不用手动把 ORM 对象转为字典。
+# 这个配置只用在响应体 Out 模型，新增和修改的请求模型不需要。
+    class Config:
+        from_attributes=True
+
+#=====班级老师中间表 class_teachers =========
+class ClassTeachersCreate(BaseModel):
+    class_id: int
+    teacher_id: int
+    role: str
+#=================响应体===================
+class ClassTeacherOut(BaseModel):
+    id: int
+    class_id: int
+    teacher_id: int
+    role: str
+    created_at: datetime
+    updated_at: datetime
+    is_deleted: int
+    class Config:
+        from_attributes=True

utils/code_generator.py

@@ -33,7 +33,7 @@ def add_student(
 '''
 
 
-
+from sqlalchemy.orm import Session
 def generate_no(field_name: str, prefix: str, db_object, db: Session):
     if getattr(db_object, field_name):             
         return