增添查询所有成绩接口，dao层运行代码-曾凯

Reviewed-on: #36

.gitignore

@@ -0,0 +1,23 @@
+# Python 缓存
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Python 虚拟环境
+.venv/
+venv/
+env/
+
+# IDE
+.idea/
+.vscode/
+
+# 系统垃圾
+.DS_Store
+Thumbs.db
+
+
+.idea/
+.idea.backup/
+.run/

README.md

@@ -1,2 +1,8 @@
 # test2222
 
+
+
+test33
+
+gesd
+jhj

api/class_api.py

@@ -0,0 +1,54 @@
+# 班级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()
+
+
+#以下分别定义增、删、改、查的路由的接口函数，以便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,summary='更新班级信息')
+def put_classes(classes:ClassUpdate,id:int,db=Depends(get_db)):
+    updates = classes.model_dump( exclude_unset=True )
+    r = update_classes_dao( id, db, updates )
+    if not r :
+        raise HTTPException(status_code=500, detail='更新失败，该班级已不存在或服务器繁忙，请稍后更新！')
+    return ClassResponse(detail='更新成功', total=1 ,data = updates )
+
+
+@classes_router.get('',summary='查询班级信息')
+def get_classes( id:int|None = None
+               , class_no:str|None = None
+               , class_name:str|None = None
+               , page:int = 1
+               , page_size:int = 5
+               , db=Depends(get_db)
+               ):
+    t,r = get_classes_dao( id , class_no , class_name , page , page_size ,db )
+    if t != 0 :
+        return ClassResponse( total = t, data = r )
+    else :
+        return ClassResponse( code = 404,detail = '没有符合条件的班级，请检查输入是否有误')
+
+
+@classes_router.delete('/{id}',response_model=ClassResponse,summary='删除班级信息')
+def delete_classes(id:int,db=Depends(get_db)):
+    r = delete_classes_dao( id , db )
+    if  r :
+        return ClassResponse( total=1,data='已成功删除班级信息' )
+    else :
+        raise HTTPException(status_code=500, detail='删除失败，该班级信息已不存在或服务器繁忙，请稍后更新！')

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,79 @@
+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)
+
+from schemas.employment import (EmploymentCreate,
+                                EmploymentUpdate,
+                                EmploymentResponse)
+
+employment_router = APIRouter(prefix="/employments", 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(
+    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": "逻辑删除成功"}

api/score.py

@@ -0,0 +1,60 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from core.database import get_db
+from dao.score import post_score_dao, update_score_dao, get_score_dao, get_all_scores_dao,delete_score_dao, exist_student_exam_dao
+from 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.get("/all", response_model=ScorePageResp,
+                   summary="所有学生成绩接口",
+                  )
+def list_all_scores(page: int = Query(1, ge=1),
+                    page_size: int = Query(10, ge=1, le=100),
+                    db: Session = Depends(get_db)):
+    total, data_list = get_all_scores_dao(page, page_size, db)
+    return {"total": total, "data": data_list}
+
+@scores_router.put("{score_id}", summary="更新成绩接口")
+def modify_score(score_id: int, req: ScoreUpdate, db: Session = Depends(get_db)):
+    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

@@ -0,0 +1,83 @@
+from fastapi import APIRouter,HTTPException,Depends
+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(tags=['statistics'])
+
+
+@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)
+        return SuccessResponse(status_code=200,msg=age_over_thirty_list)
+    except NoExist as e:
+        raise HTTPException(status_code=404,detail=str(e))
+# 这边功能函数返回的是一个字典
+@statistics_router.get("/classes/gender-count",response_model=SuccessResponse)
+def api_gender_count(db:Session=Depends(get_db)):
+    try:
+        result = gender_count(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/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

@@ -0,0 +1,96 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from core.database import get_db
+from schemas.student import StudentCreate, StudentUpdate
+from dao import student as student_dao
+student_router = APIRouter()
+
+@student_router.post("",summary='添加学生')
+def create_student(request:StudentCreate,db:Session = Depends(get_db)):
+    d = request.model_dump()
+    r = student_dao.create_students(d,db)
+    if not r:
+        raise HTTPException(status_code=500,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="修改学生失败")
+
+    return {
+        "code": 200,
+        "detail": "修改学生成功",
+        "data": student,
+    }
+
+@student_router.get("", summary="查询学生列表")
+def get_students(
+    # 三个查询条件都可以不传
+    student_no: str | None = None,
+    student_name: str | None = None,
+    class_id: int | None = None,
+    # 获取本次请求使用的数据库连接
+    db: Session = Depends(get_db),
+):
+    # 调用 DAO 查询数据库
+    students = student_dao.get_students(
+        db=db,
+        student_no=student_no,
+        student_name=student_name,
+        class_id=class_id,
+    )
+
+    return {
+        "code": 200,
+        "detail": "查询成功",
+        "total": len(students),
+        "data": students,
+    }
+
+@student_router.get("/{id}", summary="查询学生详情")
+def get_student(id: int, 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="学生不存在")
+
+    return {
+        "code": 200,
+        "detail": "查询成功",
+        "data": student,
+    }
+
+@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": "解除班级带班关系成功"}
+
+

core/database.py

@@ -9,11 +9,15 @@ IP:localhost
 
 2.如果还没开始建库，建库时统一将名称命名为 student_manager。
   如果已经建库或在 models 目录写好Base函数，那先别提交分支，不然合并的时候会出问题，后天合库的时候再说。
+
+3.在 /models 目录下写数据库对应类时，不要自己写Base = declarative_base()，
+直接 from core.database import Base ,否则会出现 Base 不一致的情况，导致数据库无法创建表。
 '''
 
+
 from sqlalchemy import create_engine
-from sqlalchemy.orm import sessionmaker
-from .config import (
+from sqlalchemy.orm import sessionmaker,declarative_base
+from core.config import (
     database_connect_user,
     database_connect_password,
     database_connect_ip,
@@ -31,3 +35,5 @@ def get_db():
         yield db
     finally:
         db.close()
+
+Base = declarative_base()

dao/class_dao.py

@@ -0,0 +1,61 @@
+# 班级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 update_classes_dao( class_id , db , updates ):
+    try :
+        r = db.query(Classes).filter(Classes.id ==class_id , Classes.is_deleted == 0 ).update(updates)
+    except :
+        db.rollback()
+        return False
+    else :
+        db.commit()
+        return r
+
+
+def get_classes_dao( class_id, class_no , class_name , page , page_size , db ):
+    q = db.query( Classes ).filter( Classes.is_deleted == 0 )
+    if class_id :
+        q = q.filter( Classes.id == class_id )
+    if class_no :
+        q = q.filter( Classes.class_no == class_no )
+    if class_name :
+        q = q.filter( Classes.class_name == class_name )
+    total = q.count()
+    r = q.offset( ( page-1 ) * page_size  ).limit( page_size ).all()
+    return total,[ { 'class_id':i.id
+                   , 'class_no':i.class_no
+                   , 'class_name':i.class_name
+                   , 'start_date':i.start_date
+                   , 'end_date':i.end_date
+                   , 'created_at':i.created_at
+                   , 'update_at':i.update_at
+                   , 'remark':i.remark
+                   }
+                      for i in r
+                 ]
+
+
+
+def delete_classes_dao( class_id , db  ):
+    try :
+        db.query( Classes ).filter( Classes.id == class_id , Classes.is_deleted == 0 ).update( {"is_deleted": 1} )
+    except :
+        db.rollback()
+        return False
+    else :
+        db.commit()
+        return True

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,97 @@
+from sqlalchemy.orm import Session
+from models.employment import Employment
+from schemas.employment import EmploymentCreate, EmploymentUpdate, EmploymentResponse
+
+
+def create_employment(db, obj_in):
+    """新增就业信息：一个学生只能存在一条就业记录"""
+    try:
+        db_obj = Employment(**obj_in.model_dump())
+        db.add(db_obj)                      # add：把对象加入数据库会话，此时还没写入数据库
+        db.commit()                         # commit：提交事务，真正写入mysql数据库
+        db.refresh(db_obj)                  # refresh：从数据库刷新对象，拿到数据库自动生成的id、默认时间等字段
+        return EmploymentResponse.model_validate(db_obj).model_dump()
+        # model_validate：把sqlalchemy ORM对象解析进pydantic响应模型
+    except Exception:
+        db.rollback()
+        return None
+
+
+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
+        return EmploymentResponse.model_validate(db_obj).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
+        return EmploymentResponse.model_validate(db_obj).model_dump()
+    except Exception:
+        return None
+
+
+def get_employment_list(db, 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 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)
+        # count()统计满足条件总条数，用于分页total
+        total = query.count()
+        # offset偏移量（跳过多少条），limit每页多少条，执行查询拿到结果列表
+        records = query.offset(skip).limit(limit).all()
+        # 列表推导式：循环每一条ORM记录，全部转为字典，得到字典列表
+        dict_list = [EmploymentResponse.model_validate(item).model_dump() for item in records]
+        # 返回字典列表 + 总条数
+        return dict_list, total
+    except Exception:
+        # 异常返回空列表，总条数0
+        return [], 0
+
+
+def update_employment(db, eid, obj_in):
+    """修改就业信息，只更新传入的字段"""
+    try:
+        db_obj_raw = db.query(Employment).filter(Employment.id == eid
+                                                ,Employment.is_deleted == 0).first()
+        if db_obj_raw is None:
+            return None
+        update_dict = obj_in.model_dump(exclude_unset=True)# exclude_unset=True：只取出前端实际传过来的字段，不会带上没传的None字段
+        for key, value in update_dict.items():
+            setattr(db_obj_raw, key, value)
+        db.commit()
+        db.refresh(db_obj_raw)
+        return EmploymentResponse.model_validate(db_obj_raw).model_dump()
+    except Exception:
+        db.rollback()
+        return None
+
+
+def delete_employment_logic(db, eid):
+    """逻辑删除，只修改is_deleted=1，不做物理删除"""
+    try:
+        db_obj_raw = db.query(Employment).filter(Employment.id == eid
+                                                 ,Employment.is_deleted == 0).first()
+        if db_obj_raw is None:
+            return False
+        db_obj_raw.is_deleted = 1
+        db.commit()
+        return True
+    except Exception:
+        db.rollback()
+        return False

dao/score.py

@@ -0,0 +1,107 @@
+from models.score import Score
+
+def post_score_dao(data_dict, db):
+    """新增成绩"""
+    try:
+        obj = Score(**data_dict)
+        db.add(obj)
+    except Exception as e:
+        print("新增成绩异常：", e)
+        db.rollback()
+        return False
+    else:
+        db.commit()
+        return True
+
+
+def update_score_dao(score_id, db, updates):
+    """修改成绩，query.update方式"""
+    try:
+        db.query(Score).filter(
+            Score.id == score_id,
+            Score.is_deleted == 0
+        ).update(updates)
+    except Exception:
+        db.rollback()
+        return False
+    else:
+        db.commit()
+        return True
+
+
+def get_score_dao(score_id, student_id, exam_seq, page, page_size, db):
+    """分页查询成绩，多条件过滤，只查未删除"""
+    q = db.query(Score).filter(Score.is_deleted == 0)
+    if score_id:
+        q = q.filter(Score.id == score_id)
+    if student_id:
+        q = q.filter(Score.student_id == student_id)
+    if exam_seq:
+        q = q.filter(Score.exam_seq == exam_seq)
+
+    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 get_all_scores_dao(page, page_size, db):
+    r = db.query(Score).filter(Score.is_deleted == 0)\
+           .order_by(Score.student_id, Score.exam_seq)
+    total = r.count()                                    # 总条数
+    rows = r.offset((page-1)*page_size).limit(page_size).all()# 分页
+    res_list_all = [
+        {
+            "id": i.id,
+            "student_id": i.student_id,
+            "score": i.score,
+            "exam_seq": i.exam_seq,
+            "exam_date": i.exam_date,
+            "remark": i.remark,
+            "created_at": i.created_at,
+            "updated_at": i.updated_at,
+            "is_deleted": i.is_deleted
+        }
+        for i in rows
+    ]
+    return total,res_list_all
+
+
+
+def delete_score_dao(score_id, db):
+    """逻辑删除，更新is_deleted=1"""
+    try:
+        db.query(Score).filter(
+            Score.id == score_id,
+            Score.is_deleted == 0
+        ).update({"is_deleted": 1})
+    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

@@ -0,0 +1,139 @@
+from schemas.statistics import NoExist
+from sqlalchemy import func
+from time import time
+#`GET /statistics/students/age-over-30`
+#查询所有超过 30 岁的学员信息
+
+def age_over_thirty(Student,db):
+    student_list=db.query(Student).filter(Student.age>30,Student.is_deleted==0).all()
+    if not student_list :
+        raise NoExist('无目标年龄大于30岁')
+    # 把每个学生对象需要返回的字段，明确放进普通字典。
+    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)).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,'总人数':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(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(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

@@ -0,0 +1,103 @@
+from schemas.student import *
+from core.database import get_db
+from models.student import *
+from sqlalchemy.orm import Session
+
+
+def create_students(d: dict, db: Session):
+    stu = Student(**d)
+
+    try:
+        db.add(stu)
+        #  把 SQL 发给数据库执行
+        db.flush()
+        # 根据 id 生成学生编号
+        if not stu.student_no:
+            stu.student_no = f"STU{stu.id:04d}"
+        db.commit()
+        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,
+):
+    # 第一步：只查询没有被删除的学生
+    query = db.query(Student).filter(Student.is_deleted == 0)
+
+    # 第二步：前端传了哪个条件，就增加哪个条件
+    if student_no:
+        # 学号使用精确查询
+        query = query.filter(Student.student_no == student_no)
+
+    if student_name:
+        # 姓名使用模糊查询，例如“张”可以查到“张三”
+        query = query.filter(Student.student_name.like(f"%{student_name}%"))
+
+    if class_id:
+        # 班级 ID 使用精确查询
+        query = query.filter(Student.class_id == class_id)
+
+    # 第三步：执行查询并返回全部结果
+    return query.all()
+
+#逻辑删除学生
+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,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()` 再生成编号会违反非空约束，需要与编号生成方案协调 |
+
+本次验证覆盖模型和建表工具，尚未完成上述业务接口的联调验证。

main.py

@@ -1,25 +1,36 @@
 from fastapi import FastAPI
 from api.example import example_router
 from middleware import log_middleware
+from api.statistics import statistics_router
 import uvicorn
+from api.student import student_router
+from api.teacher import router as teacher_router,class_teacher_router
+
 app = FastAPI()
 app.middleware("http")(log_middleware)
 
 #-------------朱婷婷--------------
+from api.class_api import classes_router
+app.include_router(classes_router,tags=['班级接口'],prefix="/classes")
 
 #-------------李玉杰--------------
-
+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(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__":

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,10 +1,11 @@
-from sqlalchemy import *
-from datetime import datetime,time,date
-
-Base = declarative_base()        # 执行函数，返回一个基类
+# 班级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      # 声明是"主键"
@@ -22,7 +23,7 @@ class Classes( Base ):              # 在python里的名字
                        )
     # ————创建班级"开课时间"的字段名————
     start_date = Column( DATE             # 声明是字段数据类型是日期
-                       , nullable = True   # 声明是'可为空'
+                       , nullable = False  # 开课时间必填
                        )
     # ————创建班级"结课时间"的字段名————
     end_date = Column( DATE               # 声明是字段数据类型是'日期'
@@ -31,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

@@ -0,0 +1,53 @@
+from sqlalchemy import (Column, Integer, String, Text,
+                        BigInteger,ForeignKey,VARCHAR,DateTime
+                        )
+from sqlalchemy.dialects.mssql import TINYINT
+
+from core.database import Base
+from datetime import datetime
+
+
+#班级老师关系表 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='逻辑删除'
+    )

models/consultant.py

@@ -0,0 +1,18 @@
+
+from sqlalchemy import *
+from sqlalchemy.dialects.mysql import TINYINT
+from datetime import datetime
+from core.database import Base
+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删除")

models/employment.py

@@ -0,0 +1,40 @@
+from sqlalchemy import *
+from sqlalchemy.orm import declarative_base,sessionmaker
+from datetime import datetime
+from core.database import Base
+
+# 为了符合三范式，就业表只保存 student_id，不保存学生姓名和班级名称。查询返回时通过关联 students 和 classes 带出学生姓名、班级名称。
+
+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删除")
+

models/score.py

@@ -0,0 +1,46 @@
+from sqlalchemy import *
+from core.database import Base
+from datetime import datetime,date
+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"
+                      )

models/student.py

@@ -0,0 +1,46 @@
+from core.database import Base
+from sqlalchemy import *
+from datetime import datetime
+
+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则表示已删除
+

models/teacher.py

@@ -0,0 +1,62 @@
+from sqlalchemy import (Column, Integer,VARCHAR,DateTime
+                        )
+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__ = '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='逻辑删除'
+    )
+
+

schemas/class_schema.py

@@ -0,0 +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                     # 班级名字"，不可为空
+    start_date : date|None = None       # 班级开课日期"，可以为空，默认为空
+    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          # 班级结课日期，可以为空，默认为空
+    remark: str|None = None               # 班级备注，可以为空，默认为空
+
+# ————定义"班级"的"响应体"模型————
+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,39 @@
+from pydantic import BaseModel, Field,ConfigDict
+from datetime import date, datetime
+from decimal import Decimal
+
+
+class EmploymentCreate(BaseModel):
+    """新增就业信息 请求体 Schema"""
+    student_id: int = Field(..., description="关联学生ID，必填")
+    employment_status: str | None = Field(None, description="就业状态：not_started/job_hunting/offered/employed")
+    employment_open_date: date | None = Field(None, description="就业开放时间，选填")
+    offer_date: date | None = Field(None, description="offer下发时间，选填")
+    company_name: str | None = Field(None, max_length=100, description="就业公司名称，选填")
+    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
+    model_config = ConfigDict(from_attributes=True) #允许pydantic从对象属性里取值

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/statistics.py

@@ -0,0 +1,4 @@
+class NoExist(Exception):
+    def __init__(self,value):
+        self.value = value
+        pass

schemas/student.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel
+from datetime import date
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+class StudentCreate(BaseModel):
+    student_no: str | None = Field(default=None, min_length=1, max_length=50)
+    student_name: str = Field(min_length=1, max_length=50)
+    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 = Field(default=None, max_length=50)
+    age: int = Field(ge=0, le=150)
+    gender: str = Field(min_length=1, max_length=10)
+
+    @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 = None
+    student_name: str | None = None
+    class_id: int | None = None
+    consultant_id: int | None = None
+    native_place: str | None = None
+    graduation_school: str | None = None
+    major: str | None = None
+    enrollment_date: date | None = None
+    graduation_date: date | None = None
+    education: str | None = None
+    age: int | None = None
+    gender: str | None = None
+

schemas/teacher.py

@@ -0,0 +1,58 @@
+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[int] = None
+    teacher_name: Optional[str] = None
+    email: Optional[str] = None
+    phone: Optional[str] = None
+    remark: Optional[str] = None
+
+class TeacherUpdate(BaseModel):
+    teacher_no: Optional[str] = None
+    teacher_name: Optional[str] = None
+    email: Optional[str] = None
+    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

@@ -0,0 +1,43 @@
+'''
+1. 参数说明：
+   field_name：业务编号字段名，例如 student_no
+   prefix：业务编号前缀，例如 STU
+   db_object：已实例化的 ORM 对象，例如 stu
+   db：当前接口中的数据库 Session
+
+2. ORM 主键统一命名为 id。
+   业务编号字段按文档命名，例如 student_no、teacher_no、class_no。
+
+3. 必须先执行 db.add(db_object)，再调用 generate_no()。
+
+4. 主键id一定要设置成自增。
+
+
+dao模块示例代码：
+def add_student(
+    result: CreateStudent,
+    db: Session
+):
+    stu = Student(**result.model_dump())
+
+    db.add(stu)
+
+    generate_no("student_no", "STU", stu, db)
+
+
+
+    db.commit()
+
+    return stu
+
+'''
+
+
+from sqlalchemy.orm import Session
+def generate_no(field_name: str, prefix: str, db_object, db: Session):
+    if getattr(db_object, field_name):             
+        return
+
+    db.flush()
+    record_no = f"{prefix}{db_object.id:04d}"
+    setattr(db_object, field_name, record_no)