api/class_api.py

@@ -10,8 +10,8 @@ classes_router = APIRouter()
 
 #以下分别定义增、删、改、查的路由的接口函数，以便api接口函数中执行
 
-# ————定义班级表"更新"信息的"接口"函数————
-@classes_router.post('/',response_model=ClassResponse,summary='新增班级信息')        # 定义班级创建路由，POST请求，指定返回数据格式为 ClassResponse
+# ————定义班级表"新增"信息的接口函数————
+@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依赖函数入参
@@ -21,34 +21,35 @@ def post_classes(classes:ClassCreate,db=Depends(get_db)):          # 定义更
         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.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='查询班级信息')
-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)
+# ————定义班级表"查询"信息的接口函数————
+@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 )
-    if t != 0 :
-        return ClassResponse( total = t, data = r )
-    else :
-        return ClassResponse( code = 404,detail = '没有符合条件的班级，请检查输入是否有误')
+    t,r = get_classes_dao( id , class_no , class_name , page , page_size ,db )  # 变量t,r用来接收dao层get_classes_dao函数的返回值，执行函数时以前端输入的id , class_no , class_name , page , page_size 、db依赖函数入参
+    if t != 0 :                                                # 判断 DAO 层的返回结果，如果为条数不为0
+        return ClassResponse( total = t, data = r )            # 返回成功响应，返回符合条件的总条数，携带符合条件的数据给前端
+    else :                                                     # 判断 DAO 层的返回结果，如果为条数为0
+        return ClassResponse( code = 404,detail = '没有符合条件的班级，请检查输入是否有误')    # 返回404响应，提示没有符合条件的提示给前端
 
-
-@classes_router.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='删除失败，该班级信息已不存在或服务器繁忙，请稍后更新！')
+# ————定义班级表"删除"信息的接口函数————
+@classes_router.delete('/{id}',response_model=ClassResponse,summary='删除班级信息')   # delete删除请求，指定返回数据格式为 ClassResponse
+def delete_classes(id:int,db=Depends(get_db)):                                           # 定义删除接口函数，id参数接收前端输入的数据，参数db依赖于数据库会话的上下文管理器
+    r = delete_classes_dao( id , db )                                                    # 变量r用来接收dao层delete_classes_dao函数的返回值，执行函数时以以前端输入的id 数据、db依赖函数入参
+    if  r :                                                                              # 判断 DAO 层的返回结果，如果是True
+        return ClassResponse( total=1,data='已成功删除班级信息' )                            # 返回成功响应和提示给前端                                                                    # 如果是False
+    raise HTTPException(status_code=500, detail='删除失败，该班级信息已不存在或服务器繁忙，请稍后更新！')  # 如果为False，抛出 500 内部服务器错误 和提示

api/employment.py

@@ -1,19 +1,16 @@
 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
-)
+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=["就业管理模块"])
 

api/teacher.py

@@ -19,7 +19,7 @@ from dao.teacher import (
     delete_class_teacher
 )
 
-router = APIRouter(prefix="/teacher", tags=["老师管理模块"])
+router = APIRouter()
 
 #============================老师表===============================
 @router.get("/list", response_model=List[TeacherOut])
@@ -77,7 +77,7 @@ def api_delete_teacher(teacher_id: int, db: Session = Depends(get_db)):
     return {"msg": "老师逻辑删除成功"}
 
 # ===================== 班级老师关联路由组 =====================
-class_teacher_router = APIRouter(prefix="/class-teacher", tags=["班级老师分配管理模块"])
+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)):

dao/class_dao.py

@@ -15,47 +15,52 @@ def post_classes_dao( c , db ):                  # 定义函数，设置两个
         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 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 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 get_classes_dao( class_id, class_no , class_name , page , page_size , db ):   # 定义函数，设置六个形参class_id, class_no , class_name , page , page_size , db
+    q = db.query( Classes ).filter( Classes.is_deleted == 0 )                     # 初始化查询语句，基础过滤条件为筛选未删除的数据 (is_deleted=0)
+    if class_id :                                                                 # 如果传入了班级id参数
+        q = q.filter( Classes.id == class_id )                                    # 则追加id过滤条件
+    if class_no :                                                                 # 如果传入了班级no参数
+        q = q.filter( Classes.class_no == class_no )                              # 则追加no过滤条件
+    if class_name :                                                               # 如果传入了班级name参数
+        q = q.filter( Classes.class_name == class_name )                          # 则追加name过滤条件
+    total = q.count()                                                             # tatal变量接收满足当前所有过滤条件的数据总条数
+    r = q.offset( ( page-1 ) * page_size  ).limit( page_size ).all()              # 变量r用来接收查询取出结果列表，计算分页偏移量（从第几行开始查），设置分页限制条数
+    return total , [                                                              # 返回 total变量总条数 和 将查询结果列表转换为字典列表的数据
+                     {
+                         'class_id':i.id                  # 提取班级ID
+                       , 'class_no':i.class_no            # 提取班级编号
+                       , 'class_name':i.class_name        # 提取班级名称
+                       , 'start_date':i.start_date        # 提取开课日期
+                       , 'end_date':i.end_date            # 提取结课日期
+                       , 'created_at':i.created_at        # 提取创建时间
+                       , 'update_at':i.update_at          # 提取更新时间
+                       , 'remark':i.remark                # 提取备注信息
+                      }
+                      for i in r                          # 循环遍历查询出的每一行数据 i
+                    ]
 
 
-
-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
+# ————定义班级表"删除"信息的函数————
+def delete_classes_dao( class_id , db  ):    # 定义函数，设置两个个形参class_id，db
+    try :                                       # 执行以下可能报错的代码
+        db.query( Classes ).filter( Classes.id == class_id , Classes.is_deleted == 0 ).update( {"is_deleted": 1} )   # 将未删除且前端输入的id和数据库id可以匹配上的数据更新is_deleted字段为1，表示已逻辑删除
+    except :                              # 捕获异常：
+        db.rollback()                     # 如果中间出错，回滚事务，防止产生脏数据
+        return False                      # 返回 False，返回接口，表示操作失败
+    else :                                # 执行成功：
+        db.commit()                       # 提交事务：更新is_deleted字段为1，表示已逻辑删除，前端无法查询到已逻辑删除的数据
+        return True                       # 返回 True，返回接口，表示操作成功

dao/employment.py

@@ -6,31 +6,22 @@ from schemas.employment import EmploymentCreate, EmploymentUpdate, EmploymentRes
 def create_employment(db, obj_in):
     """新增就业信息：一个学生只能存在一条就业记录"""
     try:
-        # obj_in.model_dump()把pydantic请求对象转为字典，解包传给Employment生成ORM对象
         db_obj = Employment(**obj_in.model_dump())
-        # add：把对象加入数据库会话，此时还没写入数据库
-        db.add(db_obj)
-        # commit：提交事务，真正写入mysql数据库
-        db.commit()
-        # refresh：从数据库刷新对象，拿到数据库自动生成的id、默认时间等字段
-        db.refresh(db_obj)
-        # model_validate：把sqlalchemy ORM对象解析进pydantic响应模型
-        # model_dump：把pydantic模型转为普通python字典返回给上层api
+        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()
-        # 异常情况返回None，上层api可以判断新增失败
         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()
+        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()
@@ -41,10 +32,8 @@ def get_employment_by_id(db, eid):
 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()
+        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()
@@ -78,16 +67,11 @@ def get_employment_list(db, company_name=None, salary_min=None, salary_max=None,
 def update_employment(db, eid, obj_in):
     """修改就业信息，只更新传入的字段"""
     try:
-        # 根据id查询未删除的记录
-        db_obj_raw = db.query(Employment).filter(
-            Employment.id == eid,
-            Employment.is_deleted == 0
-        ).first()
-        # 记录不存在直接返回None
+        db_obj_raw = db.query(Employment).filter(Employment.id == eid
+                                                ,Employment.is_deleted == 0).first()
         if db_obj_raw is None:
             return None
-        # exclude_unset=True：只取出前端实际传过来的字段，不会带上没传的None字段
-        update_dict = obj_in.model_dump(exclude_unset=True)
+        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()
@@ -101,10 +85,8 @@ def update_employment(db, eid, obj_in):
 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()
+        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

dao/teacher.py

@@ -11,14 +11,11 @@ from fastapi import HTTPException
 '''
 #=================老师表Teacher的CRUD================
 #查询所有未被删除的老师
-def get_teacher_list(db:Session, teacher_id:int):
-    teacher = get_teacher_by_id(db, teacher_id)
-    if not teacher:
-        raise HTTPException(status_code=404, detail="老师不存在或已删除！")
+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):
+def get_teacher_by_id(db:Session,teacher_id:int,):
     return db.query(Teacher).filter(Teacher.id == teacher_id
                                     ,Teacher.is_deleted == 0).first()
 #新增

main.py

@@ -4,6 +4,8 @@ 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)
 
@@ -14,7 +16,8 @@ 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)
@@ -23,9 +26,11 @@ 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/employment.py

@@ -1,13 +1,13 @@
 from sqlalchemy import *
 from sqlalchemy.orm import declarative_base,sessionmaker
 from datetime import datetime
-from core.database import Base, engine
+from core.database import Base
 
 # 为了符合三范式，就业表只保存 student_id，不保存学生姓名和班级名称。查询返回时通过关联 students 和 classes 带出学生姓名、班级名称。
 
 class Employment(Base):
-    __tablename__ = "employment_info_detail"                              # 实际数据库的表名字
-    id = Column(Integer, primary_key=True                   # 主键
+    __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

schemas/employment.py

@@ -1,4 +1,4 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field,ConfigDict
 from datetime import date, datetime
 from decimal import Decimal
 
@@ -36,3 +36,4 @@ class EmploymentResponse(BaseModel):
     remark: str | None
     created_at: datetime | None
     updated_at: datetime | None
+    model_config = ConfigDict(from_attributes=True) #允许pydantic从对象属性里取值