Merge pull request '修改请求体' (#52) from zhutt into main

Reviewed-on: #52

api/employment.py

@@ -6,13 +6,14 @@ from dao.employment import (create_employment,
                             get_employment_by_student_id,
                             get_employment_list,
                             update_employment,
-                            delete_employment_logic)
+                            delete_employment_logic,
+                            recover_employment_delete)
 
 from schemas.employment import (EmploymentCreate,
                                 EmploymentUpdate,
                                 EmploymentResponse)
 
-employment_router = APIRouter(prefix="/employments", tags=["就业管理模块"])
+employment_router = APIRouter( tags=["就业管理模块"])
 
 
 @employment_router.post("/", response_model=EmploymentResponse, summary="新增就业信息")
@@ -28,36 +29,38 @@ def add_employment(body: EmploymentCreate, db: Session = Depends(get_db)):
     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("/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)
-):
+def query_employment_list(eid:int| None = Query(None, description="就业编号"),
+                          student_id:int| None = Query(None,description="学生id"),
+                          company_name: str | None = Query(None, description="公司名称模糊查询"),
+                          salary_min: float | None = Query(None, description="最低薪资"),
+                          salary_max: float | None = Query(None, description="最高薪资"),
+                          skip: int = Query(0, ge=0, description="偏移量"),
+                          limit: int = Query(20, ge=1, le=100, description="每页条数"),
+                          db: Session = Depends(get_db)):
     # 调用dao列表查询，拿到数据字典列表和总条数
     data_list, total = get_employment_list(db, company_name, salary_min, salary_max, skip, limit)
     return {"total": total, "data": data_list}
 
 
-@employment_router.get("/{eid}", response_model=EmploymentResponse, summary="根据id查询就业详情")
-def query_employment_detail(eid: int, db: Session = Depends(get_db)):
-    """根据就业主键id查询单条就业记录"""
-    record = get_employment_by_id(db, eid)
-    if not record:
-        raise HTTPException(status_code=404, detail="就业记录不存在或已被逻辑删除")
-    return record
+# @employment_router.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="修改就业信息")
@@ -77,3 +80,12 @@ def logic_delete_employment(eid: int, db: Session = Depends(get_db)):
         raise HTTPException(status_code=404, detail="删除失败，记录不存在")
     # 删除成功返回提示字典
     return {"code": 200, "msg": "逻辑删除成功"}
+
+@employment_router.get("/{eid}", summary="回档逻辑删除就业记录")
+def recover_delete_employment(eid: int, db: Session = Depends(get_db)):
+    """执行逻辑删除，is_deleted置1，不会真正删除数据库行"""
+    ok = recover_employment_delete(db, eid)
+    if not ok:
+        raise HTTPException(status_code=404, detail="回档失败，记录已经存在")
+    # 删除成功返回提示字典
+    return {"code": 200, "msg": "回档成功"}

api/score.py

@@ -1,7 +1,7 @@
 from fastapi import APIRouter, Depends, HTTPException, Query
 from sqlalchemy.orm import Session
 from core.database import get_db
-from dao.score import post_score_dao, update_score_dao, get_score_dao, get_all_scores_dao,delete_score_dao, exist_student_exam_dao
+from dao.score import post_score_dao, update_score_dao, get_score_dao,delete_score_dao, exist_student_exam_dao
 from schemas.score import ScoreCreate, ScoreUpdate, ScorePageResp
 
 scores_router = APIRouter(prefix="/scores", tags=["成绩接口"])
@@ -32,14 +32,6 @@ def list_score(
 
 
 
-@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)):

dao/employment.py

@@ -1,17 +1,28 @@
-from sqlalchemy.orm import Session
 from models.employment import Employment
-from schemas.employment import EmploymentCreate, EmploymentUpdate, EmploymentResponse
+from schemas.employment import  EmploymentResponse
 
 
-def create_employment(db, obj_in):
+def create_employment(db, e):
+    # obj_in是Pydantic对象(EmploymentCreate)
     """新增就业信息：一个学生只能存在一条就业记录"""
     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响应模型
+        db_obj = Employment(**e.model_dump())
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+
+        resp = EmploymentResponse(id=db_obj.id
+                                  ,student_id=db_obj.student_id
+                                  ,employment_status=db_obj.employment_status
+                                  ,employment_open_date=db_obj.employment_open_date
+                                  ,offer_date=db_obj.offer_date
+                                  ,company_name=db_obj.company_name
+                                  ,salary=db_obj.salary
+                                  ,remark=db_obj.remark
+                                  ,created_at=db_obj.created_at
+                                  ,updated_at=db_obj.updated_at)
+        return resp.model_dump()
+
     except Exception:
         db.rollback()
         return None
@@ -24,7 +35,18 @@ def get_employment_by_id(db, eid):
                                              ,Employment.is_deleted == 0).first()
         if not db_obj:
             return None
-        return EmploymentResponse.model_validate(db_obj).model_dump()
+
+        resp = EmploymentResponse(id=db_obj.id
+                                  ,student_id=db_obj.student_id
+                                  ,employment_status=db_obj.employment_status
+                                  ,employment_open_date=db_obj.employment_open_date
+                                  ,offer_date=db_obj.offer_date
+                                  ,company_name=db_obj.company_name
+                                  ,salary=db_obj.salary
+                                  ,remark=db_obj.remark
+                                  ,created_at=db_obj.created_at
+                                  ,updated_at=db_obj.updated_at)
+        return resp.model_dump()
     except Exception:
         return None
 
@@ -36,62 +58,115 @@ def get_employment_by_student_id(db, student_id):
                                              ,Employment.is_deleted == 0).first()
         if not db_obj:
             return None
-        return EmploymentResponse.model_validate(db_obj).model_dump()
+
+        resp = EmploymentResponse(id=db_obj.id
+                                  ,student_id=db_obj.student_id
+                                  ,employment_status=db_obj.employment_status
+                                  ,employment_open_date=db_obj.employment_open_date
+                                  ,offer_date=db_obj.offer_date
+                                  ,company_name=db_obj.company_name
+                                  ,salary=db_obj.salary
+                                  ,remark=db_obj.remark
+                                  ,created_at=db_obj.created_at
+                                  ,updated_at=db_obj.updated_at)
+        return resp.model_dump()
     except Exception:
         return None
 
 
-def get_employment_list(db, company_name=None, salary_min=None, salary_max=None, skip=0, limit=20):
+def get_employment_list(db, id=None,student_id=None,company_name=None, salary_min=None, salary_max=None, skip=0, limit=20):
     """就业列表查询；支持公司名模糊、薪资范围筛选；只查询is_deleted=0"""
     try:
         query = db.query(Employment).filter(Employment.is_deleted == 0)
+        if id is not None:
+            query = query.filter(Employment.id >= id)
+        if student_id is not None:
+            query = query.filter(Employment.student_id >= student_id)
         if company_name:
             query = query.filter(Employment.company_name.like(f"%{company_name}%"))
         if salary_min is not None:
             query = query.filter(Employment.salary >= salary_min)
         if salary_max is not None:
             query = query.filter(Employment.salary <= salary_max)
-        # 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]
-        # 返回字典列表 + 总条数
+
+        dict_list = []
+        for item in records:
+            resp = EmploymentResponse(id=item.id
+                                      ,student_id=item.student_id
+                                      ,employment_status=item.employment_status
+                                      ,employment_open_date=item.employment_open_date
+                                      ,offer_date=item.offer_date
+                                      ,company_name=item.company_name
+                                      ,salary=item.salary
+                                      ,remark=item.remark
+                                      ,created_at=item.created_at
+                                      ,updated_at=item.updated_at)
+            dict_list.append(resp.model_dump())
+
         return dict_list, total
     except Exception:
-        # 异常返回空列表，总条数0
         return [], 0
 
 
-def update_employment(db, eid, obj_in):
+def update_employment(db, eid, e):
     """修改就业信息，只更新传入的字段"""
     try:
-        db_obj_raw = db.query(Employment).filter(Employment.id == eid
-                                                ,Employment.is_deleted == 0).first()
-        if db_obj_raw is None:
+        x = db.query(Employment).filter(Employment.id == eid
+                                                 ,Employment.is_deleted == 0).first()
+        if x 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)
+
+        update_dict = e.model_dump(exclude_unset=True)
+        db.query(Employment).filter(Employment.id == eid
+                                    ,Employment.is_deleted == 0).update(update_dict)
+
         db.commit()
-        db.refresh(db_obj_raw)
-        return EmploymentResponse.model_validate(db_obj_raw).model_dump()
+        db.refresh(x)
+
+        resp = EmploymentResponse(id=x.id
+                                  ,student_id=x.student_id
+                                  ,employment_status=x.employment_status
+                                  ,employment_open_date=x.employment_open_date
+                                  ,offer_date=x.offer_date
+                                  ,company_name=x.company_name
+                                  ,salary=x.salary
+                                  ,remark=x.remark
+                                  ,created_at=x.created_at
+                                  ,updated_at=x.updated_at)
+        return resp.model_dump()
+
     except Exception:
         db.rollback()
-        return None
+        return
+
 
 
 def delete_employment_logic(db, eid):
     """逻辑删除，只修改is_deleted=1，不做物理删除"""
     try:
-        db_obj_raw = db.query(Employment).filter(Employment.id == eid
+        y = db.query(Employment).filter(Employment.id == eid
                                                  ,Employment.is_deleted == 0).first()
-        if db_obj_raw is None:
+        if y is None:
             return False
-        db_obj_raw.is_deleted = 1
+        y.is_deleted = 1
         db.commit()
         return True
     except Exception:
         db.rollback()
         return False
+
+def recover_employment_delete(db, eid):
+    """逻辑删除，只修改is_deleted=1，不做物理删除"""
+    try:
+        y = db.query(Employment).filter(Employment.id == eid).first()
+        if y is None:
+            return False
+        y.is_deleted = 0
+        db.commit()
+        return True
+    except Exception:
+        db.rollback()
+        return False

dao/score.py

@@ -5,23 +5,27 @@ def post_score_dao(data_dict, db):
     try:
         obj = Score(**data_dict)
         db.add(obj)
+        db.commit()
     except Exception as e:
         print("新增成绩异常：", e)
         db.rollback()
         return False
     else:
-        db.commit()
         return True
 
 
 def update_score_dao(score_id, db, updates):
     """修改成绩，query.update方式"""
     try:
-        db.query(Score).filter(
+        cnt = db.query(Score).filter(
             Score.id == score_id,
             Score.is_deleted == 0
         ).update(updates)
-    except Exception:
+        if cnt == 0:
+            db.rollback()
+            return False
+    except Exception as e:
+        print("修改成绩异常：", e)
         db.rollback()
         return False
     else:
@@ -30,14 +34,25 @@ def update_score_dao(score_id, db, updates):
 
 
 def get_score_dao(score_id, student_id, exam_seq, page, page_size, db):
-    """分页查询成绩，多条件过滤，只查未删除"""
+    """分页查询成绩，多条件过滤，只查未删除
+    规则：
+      - score_id == 0                → 查所有学生成绩（仅分页，不加 id 过滤）
+      - 三个筛选条件全为空（None）   → 直接返回空，不查库
+      - 其他情况                     → 按传入条件过滤
+    """
     q = db.query(Score).filter(Score.is_deleted == 0)
-    if score_id:
-        q = q.filter(Score.id == score_id)
-    if student_id:
-        q = q.filter(Score.student_id == student_id)
-    if exam_seq:
-        q = q.filter(Score.exam_seq == exam_seq)
+
+    if score_id == 0:
+        pass                                  # score_id=0 → 查全部（分页）
+    elif score_id is None and not student_id and not exam_seq:
+        return 0, []                          # 三个参数都没传 → 返回空
+    else:
+        if score_id:
+            q = q.filter(Score.id == score_id)
+        if student_id:
+            q = q.filter(Score.student_id == student_id)
+        if exam_seq:
+            q = q.filter(Score.exam_seq == exam_seq)
 
     total = q.count()
     rows = q.offset((page - 1) * page_size).limit(page_size).all()
@@ -58,36 +73,20 @@ def get_score_dao(score_id, student_id, exam_seq, page, page_size, db):
     ]
     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(
+        cnt = db.query(Score).filter(
             Score.id == score_id,
             Score.is_deleted == 0
-        ).update({"is_deleted": 1})
+        ).update({"is_deleted": 1})     # ← 接住返回值
+        if cnt == 0:                    # ← 关键：一行都没匹配到
+            db.rollback()
+            return False
     except Exception as err:
         print("删除成绩异常：", err)
         db.rollback()

dao/statistics.py

@@ -1,6 +1,6 @@
 from schemas.statistics import NoExist
 from sqlalchemy import func
-from time import time
+
 #`GET /statistics/students/age-over-30`
 #查询所有超过 30 岁的学员信息
 

magic_llm/llm_func.py

@@ -16,7 +16,7 @@ def llm_func(input_user):
     base_url="https://api.deepseek.com"
     )
 
-    prom_path = Path(__file__).parent / "prom.txt"
+    prom_path = Path(__file__).parent / "prom.txt"   #拼接路径
     context = prom_path.read_text(encoding="utf-8")
 
 

main.py

@@ -7,7 +7,7 @@ from api.student import student_router
 from api.teacher import router as teacher_router,class_teacher_router
 from api.magic import magic_router
 
-app = FastAPI()
+app = FastAPI(title='学生管理系统')
 app.middleware("http")(log_middleware)
 app.include_router(magic_router)
 

models/class_model.py

@@ -25,12 +25,8 @@ class Classes( Base ):              # 在python里的名字
     start_date = Column( DATE             # 声明是字段数据类型是日期
                        , nullable = False  # 开课时间必填
                        )
-    # ————创建班级"计划结课时间"的字段名————
-    pland_end_date = Column( DATE               # 声明是字段数据类型是'日期'
-                     , nullable = True     # 声明是"可为空"
-                     )
-    # ————创建班级"实际结课时间"的字段名————
-    true_end_date = Column( DATE               # 声明是字段数据类型是'日期'
+    # ————创建班级"结课时间"的字段名————
+    end_date = Column( DATE               # 声明是字段数据类型是'日期'
                      , nullable = True     # 声明是"可为空"
                      )
     # ————创建班级"创建时间"的字段名————

models/employment.py

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

schemas/employment.py

@@ -1,12 +1,12 @@
-from pydantic import BaseModel, Field,ConfigDict
+from pydantic import BaseModel, Field
 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")
+    student_id: int = Field(..., description="关联学生ID，必填")# description：在Swagger页面展示字段说明文字
+    employment_status: str | None = Field(None, description="就业状态,选填")
     employment_open_date: date | None = Field(None, description="就业开放时间，选填")
     offer_date: date | None = Field(None, description="offer下发时间，选填")
     company_name: str | None = Field(None, max_length=100, description="就业公司名称，选填")
@@ -36,4 +36,3 @@ class EmploymentResponse(BaseModel):
     remark: str | None
     created_at: datetime | None
     updated_at: datetime | None
-    model_config = ConfigDict(from_attributes=True) #允许pydantic从对象属性里取值