11

# Conflicts:
#	class_management/main.py

Teachers/api/tea_api.py

@@ -11,7 +11,7 @@ tea_api = APIRouter()
 
 @tea_api.post('/tea',response_model=TeaResponse,summary='新增老师',description='输入新增的老师信息，除去姓名外可以为空')
 def add_tea(tea: NewTeaRequest=Depends(),db=Depends(get_db)):
-    r = add_tea_dao(tea.model_dump(exclude_unset=True),db)
+    r = add_tea_dao(tea.model_dump(),db)
     if not r:
         raise HTTPException(status_code=500,detail='添加失败！')
     return TeaResponse(totals=1,data=tea.model_dump())
@@ -48,7 +48,7 @@ def delete_other_tea_dao1(t:TeaRequest=Depends(),db=Depends(get_db)):
 @tea_api.post('/subject',summary='新增科目',description='输入新增的科目')
 def add_sub(t:SubRequest=Depends(),db=Depends(get_db)):   #开启会话窗口
     r = add_subject_dao(t.model_dump(),db=db)
-    if r=='已存在':
+    if not r:
         raise HTTPException(status_code=500,detail='科目已存在')
     return TeaResponse(totals=len(r), data=r)
 

Teachers/dao/tea_dao.py

@@ -50,8 +50,8 @@ def get_tea_dao(t,db):
         query = query.filter(Tea.sex == t.get('sex') )
     if t.get('class_id'):
         query = query.filter(Tea.class_id == t.get('class_id') )
-    if t.get('subject_id'):
-        query = query.filter(Tea.subject_id == t.get('subject_id') )
+    if t.get('sub'):
+        query = query.filter(Tea.sub == t.get('sub') )
     if t.get('home_place'):
         query = query.filter(Tea.home_place == t.get('home_place') )
     if t.get('specialty'):
@@ -67,7 +67,7 @@ def get_tea_dao(t,db):
     if t.get('phone'):
         query = query.filter(Tea.phone == t.get('phone') )
     r = query.all()
-    return [{'id':i.id,'name':i.name,'class_id':i.class_id,'sub':i.subject_id,'sex':i.sex,'home_place':i.home_place
+    return [{'id':i.id,'name':i.name,'class_id':i.class_id,'sub':i.sub,'sex':i.sex,'home_place':i.home_place
                 ,'specialty':i.specialty,'start_time':i.start_time,'work_experience':i.work_experience
                 ,'collage':i.collage,'phone':i.phone} for i in r]
 
@@ -98,8 +98,8 @@ def delete_other_tea_dao(t,db):
             query1 = query1.filter(Tea.sex == t.get('sex'))
         if t.get('class_id'):
             query1 = query1.filter(Tea.class_id == t.get('class_id'))
-        if t.get('subject_id'):
-            query1 = query1.filter(Tea.subject_id == t.get('subject_id'))
+        if t.get('sub'):
+            query1 = query1.filter(Tea.sub == t.get('sub'))
         if t.get('home_place'):
             query1 = query1.filter(Tea.home_place == t.get('home_place'))
         if t.get('collage'):
@@ -128,17 +128,15 @@ def add_subject_dao(t,db):
     try:
         t1 = db.query(Sub).filter(Sub.name == t.get('name')).first()
         if t1:
-            return'已存在'
+            print('科目已存在')
+            raise Exception('科目已存在')
         s1 = Sub(**t)
         db.add(s1)
         db.commit()
-        return '[s1]'
-    except InterruptedError as e:
+        return '添加成功'
+    except Exception as e:
         db.rollback()
         print('失败的原因',e)
         return False
-    except Exception as e:
-        db.rollback()
-        return f'{e}'
 
 

Teachers/database.py

@@ -24,5 +24,4 @@ def get_db():
         yield db
     finally:
         db.close()
-#建表
 Base.metadata.create_all(engine1)

Teachers/model/tea_model.py

@@ -16,14 +16,17 @@ class Tea(Base_all):
                     ,autoincrement=True
                     ,comment='id')
     name = Column(String(50)
+                      ,nullable=False
                       ,comment='姓名')
     sex = Column(Enum(Gender),default='未知'
                      ,comment='性别')
     class_id = Column(Integer
+                      ,nullable=False
                       ,comment='班级id')
     phone = Column(String(50))
     subject_id = Column(Integer
                         , ForeignKey('subject.id')
+                       ,nullable=False
                        ,comment='教学科目')
     home_place = Column(String(50)
                         ,comment='家乡')

Teachers/schema/tea_request.py

@@ -7,7 +7,7 @@ class TeaRequest(BaseModel):
     name: str|None = None
     sex: Gender|None = None
     class_id: int | None = None
-    subject_id: str|None = None
+    sub: str|None = None
     phone: str | None
     home_place: str|None = None
     collage: str|None = None
@@ -22,7 +22,7 @@ class NewTeaRequest(BaseModel):
     name: str | None = None
     sex: Gender|None = None
     class_id: int | None = None
-    subject_id: int | None = None
+    sub: str | None = None
     home_place: str | None = None
     phone: str | None = Field(default=None, min_length=11, max_length=11)
     collage: str | None = None
@@ -35,7 +35,7 @@ class NewTeaRequest1(BaseModel):
     name: str | None = None
     sex: Gender|None = None
     class_id: int | None = None
-    subject_id: int | None = None
+    sub: str | None = None
     home_place: str | None = None
     phone: str | None = Field(default=None, min_length=11, max_length=11)
     collage: str | None = None
@@ -45,4 +45,4 @@ class NewTeaRequest1(BaseModel):
     specialty: str | None = None
 
 class SubRequest(BaseModel):
-    name: str
+    name: str | None = None

class_management/dao/class_management_dao.py

@@ -4,6 +4,12 @@ from sqlalchemy.orm import Session
 #新增班级
 def add_class_dao(c,db):
     try:
+        exist_class = db.query(ClassInfo).filter(
+            ClassInfo.num == c["num"],
+            ClassInfo.is_delete == 0
+        ).first()
+        if exist_class:
+            return False
         c1 = ClassInfo(**c)
         db.add(c1)
     except:
@@ -11,6 +17,7 @@ def add_class_dao(c,db):
         return False
     else:
         db.commit()
+        db.refresh(c1)
         return True
 
 

class_management/database.py

@@ -11,9 +11,9 @@ DB_HOST = os.getenv("DB_HOST", "localhost")
 DB_PORT = os.getenv("DB_PORT", "3306")
 DB_NAME = os.getenv("DB_NAME", "student_manage_system")
 
-class_management_url = "mysql+pymysql://root:123456@localhost:3306/student_manage_system?charset=utf8mb4"
+class_management_rul = f"mysql+pymysql://{DB_USER}:{DB_PASSWORD}@{DB_HOST}:{DB_PORT}/{DB_NAME}?charset=utf8mb4"
 
-engine = create_engine(class_management_url)
+engine = create_engine(class_management_rul)
 SessionLocal = sessionmaker(bind=engine,autocommit=False, autoflush=False)
 Base = declarative_base()
 

class_management/main.py

@@ -3,17 +3,16 @@ from class_management.api.class_management_api import class_api
 from class_management.model.class_management_model import ClassInfo
 from class_management.database import Base,engine
 
-
 # 合并接口
 Classes_API = APIRouter()
 Classes_API.include_router(class_api)
 
-# 自测接口
-app = FastAPI()
-
-app.include_router(class_api)
-
 if __name__ =='__main__':
+    # 自测接口
+    app = FastAPI()
+
+    app.include_router(class_api)
+
     Base.metadata.create_all(engine)
 
     import uvicorn

class_management/model/class_management_model.py

@@ -22,16 +22,16 @@ class ClassInfo(Base_all):
                         ,comment='班级名称'
                         )
     head_teacher_id = Column(Integer
-                            ,ForeignKey('teacher.id')
+                            ,ForeignKey('teachers.id')
                             ,comment='班主任编号'
                             )
 
     coach_teacher_id = Column(Integer
-                              ,ForeignKey('teacher.id')
+                              ,ForeignKey('teachers.id')
                               ,comment='授课老师编号'
                               )
     tutor_teacher_id = Column(Integer
-                              ,ForeignKey('teacher.id')
+                              ,ForeignKey('teachers.id')
                               ,comment='助教老师编号'
                               )
     class_start_time = Column(Date

main.py

@@ -9,12 +9,12 @@ from databases import *
 app = FastAPI(title="学生管理系统")
 
 
-app.include_router(Classes_API,tags=["classes"])
-app.include_router(Scores_API,tags=["scores"])
-app.include_router(Shtudent_Jiuye,tags=["Employments"])
-app.include_router(Students_API,tags=["students"])
-app.include_router(Teachers_API,tags=["teachers"])
-app.include_router(StatCalc_API,tags=["StatCalc"])
+app.include_router(Classes_API,tags=["班级管理模块"])
+app.include_router(Scores_API,tags=["学生考核成绩管理模块"])
+app.include_router(Shtudent_Jiuye,tags=["学生就业管理模块"])
+app.include_router(Students_API,tags=["学生管理模块"])
+app.include_router(Teachers_API,tags=["老师管理模块"])
+app.include_router(StatCalc_API,tags=["统计分析模块"])
 
 
 if __name__ == "__main__":

stu_jiuye/CURD_api.py

@@ -93,7 +93,7 @@ def delete_stuinfo(                                         #删除模块
                    ):                                       #根据id选择对象
     rows = delete_emp_dao(id, db)                           #调用删除函数
     if not rows:
-        raise HTTPException(status_code=500, detail='没有删除！')        #失败返回错误信息
+        raise HTTPException(status_code=404, detail='未找到该就业记录！')        #失败返回错误信息
     return {'code': 200, 'totals': rows, 'detail': '删除成功'}          #成功返回信息
 
 '''

stu_jiuye/dao.py

@@ -18,6 +18,7 @@ def add_employment_dao(o,db):               #新增就业信息函数
         return False
     else:
         db.commit()                                                 #提交事务，永久保存
+        db.refresh(o1)
         return True
 
 def add_company_dao(o,db):                 #添加公司信息函数
@@ -34,6 +35,7 @@ def add_company_dao(o,db):                 #添加公司信息函数
         return False
     else:
         db.commit()                                                 #提交事务，永久保存
+        db.refresh(o1)
         return True
 def add_address_dao(o,db):              #添加地址区域信息函数
     try:
@@ -49,6 +51,7 @@ def add_address_dao(o,db):              #添加地址区域信息函数
         return False
     else:
         db.commit()                                             #提交事务，永久保存
+        db.refresh(o1)
         return True
 
 
@@ -82,24 +85,23 @@ def get_emp_dao(                                                 #获取学生
                    # ,page
                    # ,page_size
                    ):                                           #根据选择条件获取信息
-    q = db.query(Employments,Company.employment_company,Address.somewhere) \
-        .outerjoin(Company, Students.id == Employments.stuid) \
-        .outerjoin(Company, ClassInfo.id == Employments.class_id)\
-        .outerjoin(Company,Employments.company_id==Company.id)\
-        .outerjoin(Address,Company.address_id==Address.id)\
-        .filter(Employments.is_deleted == 0)                    #连接公司表和地址表，筛选未被删除信息
+    q = (db.query(Employments,Company.employment_company,Address.somewhere)
+        .outerjoin(Students, Students.id == Employments.stuid)
+        .outerjoin(ClassInfo, ClassInfo.id == Employments.class_id)
+        .outerjoin(Company,Employments.company_id==Company.id)
+        .outerjoin(Address,Employments.address_id==Address.id)
+        .filter(Employments.is_deleted == 0))                    #连接公司表和地址表，筛选未被删除信息
     # if stuid:
     #     q = q.filter( Employments.id == stuid )
 
     if sname:                                                 #根据学生姓名筛选
         q = q.filter( Students.name == sname )
     if class_id:
-        q = q.filter(ClassInfo.id == class_id)
+        q = q.filter(Employments.class_id == class_id)
     if somewhere:
         q = q.filter(Address.somewhere.like(f'%{somewhere}%'))
     if employment_company:                                                #根据公司姓名筛选
         q=q.filter(Company.employment_company.like(f'%{employment_company}%'))
-    # r = q.offset( (page-1)*page_size ).limit( page_size ).all()
     if min_salary is not None:                                  #根据最小薪资筛选
         q = q.filter(Employments.employment_salary >= min_salary)
     if max_salary is not None:                                    ##根据最大薪资筛选
@@ -116,20 +118,18 @@ def get_emp_dao(                                                 #获取学生
     r= q.all()
     if r:
         return [ {"id": i.id,
-                  '学生姓名':i.sname,
+                  '学生姓名':sname,
                   '学生班级编号':i.class_id,
                  "公司": employment_company or '未就业',
                   "公司区域":somewhere or '-',
-                  # "company_id": i.company_id,
                   "薪资":i.employment_salary or '-',
-                 # "address_id": i.address_id,
                   "就业开放时间":i.employment_open_time.strftime('%Y-%m-%d') ,
                   "offer下发时间":i.offer_recived_time.strftime('%Y-%m-%d')
                 # , "创建时间": i.create_time,
                 # "更新时间": i.update_time,
                 #  "是否删除":i.is_deleted
-                 } for i,sname,class_id,employment_company,somewhere in r ]        #返回信息列表
-
+                 } for i,sname,employment_company,somewhere in r ]        #返回信息列表
+    return {"code": 200, "totals": len(r), "data": r}
 
 def delete_emp_dao(id,db):                  #删除函数
     try:

stu_jiuye/model.py

@@ -19,12 +19,14 @@ class Employments(Base_all):                                            #学生
     class_id  = Column(Integer
                          , ForeignKey('classes.id')
                             )                               #学生班级，冗余字段
-    company_id = Column(Integer                                  #公司id，外键匹配公司表
+    company_id = Column(Integer  # 公司id，外键匹配公司表
                         , ForeignKey('Company.id')
                         , nullable=True
-
                         )
-
+    address_id = Column(Integer  # 地址id,匹配地址表
+                        , ForeignKey('Address.id')  # 外键地址表id
+                        , nullable=False  # 非空约束
+                        )
     employment_salary  = Column(Integer, nullable=True)                                    #薪资
 
     employment_open_time = Column(DATE, nullable=True)                 #就业开放时间
@@ -49,10 +51,7 @@ class Company(Base_all):                                                #公司
     employment_company = Column(String(50)                                #公司姓名
                       , nullable=False                                #非空约束
                       )
-    address_id = Column(Integer                                 #地址id,匹配地址表
-                        , ForeignKey('Address.id')                  #外键地址表id
-                        , nullable=False                            #非空约束
-                        )
+
     create_time = Column(DATETIME
                           , default=datetime.now
                           )
@@ -71,6 +70,7 @@ class Address(Base_all):
     somewhere=Column(String(50)                                 #地址区域
                      , nullable=False
                      )
+
     create_time = Column(DATETIME
                           , default=datetime.now
                           )

stu_jiuye/request.py

@@ -4,10 +4,10 @@ from pydantic import BaseModel
 
 class PostRequest(BaseModel):                                       #学生就业信息请求体模型
     # compname: str|None=None
-    sname: str|None=None
+    stuid: int|None=None
     class_id: int|None=None
     company_id:int|None=None
-    # address_id: int|None=None
+    address_id: int|None=None
     employment_salary: int|None=None
     employment_open_time:date|None=None
     offer_recived_time:date|None=None
@@ -21,7 +21,7 @@ class EmpResponse(BaseModel):                                       #学生就
 
 class CompRequest(BaseModel):                                       #公司信息请求体模型
     employment_company:str
-    address_id: int
+    # address_id: int
 
 class CompResponse(BaseModel):                                  #公司信息响应体
     code: int = 200

stu_jiuye/就业模块文档.md

@@ -0,0 +1,377 @@
+# 学生就业信息管理系统 —— 就业模块项目文档
+
+## 一、模块概述
+
+本模块是「学生就业信息管理系统」的核心业务模块，负责管理学生就业状态的全生命周期。围绕就业信息（Employments）、公司信息（Company）、地址信息（Address）三张核心表，并与学生表（students）、班级表（classes）建立外键关联，提供增删改查（CRUD）与统计分析接口。
+
+**技术栈：**
+
+
+
+| 项      | 选型                    |
+| ------ | --------------------- |
+| Web 框架 | FastAPI               |
+| ORM    | SQLAlchemy 2.x        |
+| 数据库    | MySQL 8.x（驱动 PyMySQL） |
+| 数据校验   | Pydantic v2           |
+| 服务启动   | Uvicorn               |
+
+## 二、目录结构
+
+
+
+```
+student\_manage\_system/
+
+├── main.py                # 程序入口：注册全模块路由、建表（\_\_main\_\_ 中执行）
+
+├── databases.py           # 根数据库配置：engine\_all / Base\_all / Session / get\_db
+
+└── stu\_jiuye/             # 就业模块业务包
+
+    ├── main.py            # 路由组装（Shtudent\_Jiuye）；独立自测 app
+
+    ├── database.py        # 模块级数据库配置（engine / Base / Session / get\_db）
+
+    ├── model.py           # ORM 模型：Employments / Company / Address
+
+    ├── request.py         # Pydantic 请求体 / 响应体模型
+
+    ├── dao.py             # 数据访问层（纯数据库操作）
+
+    └── CURD\_api.py        # 路由层（API 接口定义）
+```
+
+**分层职责：**
+
+
+
+| 层     | 文件           | 职责                          |
+| ----- | ------------ | --------------------------- |
+| 路由层   | CURD\_api.py | 接收 HTTP 请求，参数校验，调用 DAO，返回响应 |
+| 数据访问层 | dao.py       | 封装 SQLAlchemy 查询与事务，向上提供函数  |
+| 模型层   | model.py     | 定义表结构与外键关系                  |
+| 校验层   | request.py   | 定义请求体 / 响应体的字段与类型           |
+| 配置层   | database.py  | 数据库 URL、引擎、Session 工厂       |
+
+## 三、数据表设计
+
+### 1. Employments（就业信息表）
+
+
+
+| 字段                     | 类型       | 约束                        | 说明                 |
+| ---------------------- | -------- | ------------------------- | ------------------ |
+| id                     | Integer  | PK, 自增                    | 主键                 |
+| stuid                  | Integer  | FK → students.id          | 学生 ID              |
+| class\_id              | Integer  | FK → classes.id           | 班级 ID              |
+| company\_id            | Integer  | FK → Company.id, 可空       | 就业公司               |
+| address\_id            | Integer  | FK → Address.id, NOT NULL | 就业地址               |
+| employment\_salary     | Integer  | 可空                        | 就业薪资               |
+| employment\_open\_time | DATE     | 可空                        | 就业开放时间             |
+| offer\_recived\_time   | DATE     | 可空                        | Offer 下发时间         |
+| create\_time           | DateTime | default=now               | 创建时间               |
+| update\_time           | DateTime | default=now, onupdate=now | 更新时间               |
+| is\_deleted            | Integer  | default=0                 | 软删除标记（0 正常 / 1 已删） |
+
+### 2. Company（公司表）
+
+
+
+| 字段                  | 类型         | 约束                        | 说明    |
+| ------------------- | ---------- | ------------------------- | ----- |
+| id                  | Integer    | PK, 自增                    | 主键    |
+| employment\_company | String(50) | NOT NULL                  | 公司名称  |
+| create\_time        | DateTime   | default=now               | 创建时间  |
+| update\_time        | DateTime   | default=now, onupdate=now | 更新时间  |
+| is\_deleted         | Integer    | default=0                 | 软删除标记 |
+
+### 3. Address（地址表）
+
+
+
+| 字段           | 类型         | 约束                        | 说明              |
+| ------------ | ---------- | ------------------------- | --------------- |
+| id           | Integer    | PK, 自增                    | 主键              |
+| somewhere    | String(50) | NOT NULL                  | 地址区域，如 "深圳市南山区" |
+| create\_time | DateTime   | default=now               | 创建时间            |
+| update\_time | DateTime   | default=now, onupdate=now | 更新时间            |
+| is\_deleted  | Integer    | default=0                 | 软删除标记           |
+
+### 表关系图
+
+
+
+```
+students (1) ───< (N) Employments (N) >─── (1) Company
+
+classes  (1) ───< (N)         |  (N) >─── (1) Address
+```
+
+
+
+* 一个学生可有多个就业记录，一条就业记录对应一个学生（通过 stuid 关联学生表）
+
+* 一条就业记录对应一个公司（company\_id）与一个地址（address\_id）
+
+* 通过多表 JOIN 可从就业记录直接获取学生姓名、班级名称、公司名称与地址信息
+
+**设计说明：姓名 / 班级不冗余，走 JOIN 获取**
+
+与 "在就业表冗余学生姓名" 的方案不同，本模块选择通过 `stuid`、`class_id` 外键关联学生表与班级表，查询时动态 JOIN 获取姓名与班级名。代价是查询多一次 JOIN；好处是学生姓名 / 班级变更后无需同步，数据天然一致。
+
+## 四、API 功能清单（CRUD）
+
+接口定义于 `CURD_api.py` 的 `CURD` 路由，由根 `../main.py` 以 `Shtudent_Jiuye` 挂载。
+
+### 📌 新增（Create）
+
+
+
+| 方法   | 路径                   | 功能       | 请求体         |
+| ---- | -------------------- | -------- | ----------- |
+| POST | /emp/company/address | 新增地址区域   | AddRequest  |
+| POST | /emp/company         | 新增公司     | CompRequest |
+| POST | /emp                 | 新增学生就业信息 | PostRequest |
+
+> 注意：由于外键依赖，建议按 Address → Company → Employments 的顺序添加。
+
+### 📌 查询（Read）
+
+
+
+| 方法  | 路径   | 功能        | 查询参数                                                                                                                                                                         |
+| --- | ---- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GET | /emp | 多条件查询就业信息 | sname、class\_id、employment\_company、min\_salary、max\_salary、somewhere、employment\_open\_start、employment\_open\_end、offer\_recived\_start、offer\_recived\_end（全部可选，均不传则查询全部） |
+
+> 就业薪资 Top5、就业时长、平均就业时长等统计接口已迁移至统计分析模块（StatCalc）：
+>
+> `/statcalc/top`
+>
+> 、
+>
+> `/statcalc/job`
+>
+> 、
+>
+> `/statcalc/avgjob`
+>
+> 。
+
+### 📌 更新（Update）
+
+
+
+| 方法  | 路径        | 功能     | 参数                                  |
+| --- | --------- | ------ | ----------------------------------- |
+| PUT | /emp?id=X | 修改就业信息 | Query：id；Body：PostRequest（支持部分字段更新） |
+
+### 📌 删除（Delete）
+
+
+
+| 方法     | 路径        | 功能      | 参数      |
+| ------ | --------- | ------- | ------- |
+| DELETE | /emp/{id} | 软删除就业信息 | Path：id |
+
+**删除说明**：本模块采用软删除（`is_deleted = 1`），数据不会从物理表中移除，便于审计与恢复。
+
+## 五、核心流程示例
+
+### 查询流程（GET /emp）
+
+
+
+```
+前端 → CURD\_api.get\_stuinfo()
+
+&#x20;      ↓ 收集 10 个可选查询条件
+
+&#x20;      ↓ 调用 get\_emp\_dao()
+
+&#x20;      ↓ DAO 五表 OUTER JOIN：Employments + Students + ClassInfo + Company + Address
+
+&#x20;      ↓ 动态拼接 filter（姓名/班级/公司/薪资范围/地址/时间范围）
+
+&#x20;      ↓ 统一过滤 is\_deleted = 0
+
+&#x20;      ↓ 返回 list\[dict]（含学生姓名、班级名称、公司、区域、薪资、时间）
+
+&#x20;      ↓ 结果为空 → 404「名单不存在」
+```
+
+### 添加流程（POST /emp）
+
+
+
+```
+前端 → CURD\_api.add\_stuinfo()
+
+&#x20;      ↓ p.model\_dump() 转 dict
+
+&#x20;      ↓ add\_employment\_dao()
+
+&#x20;      ↓ o.pop('id' / 'create\_time' / 'update\_time' / 'is\_deleted') 去掉自增主键与自动字段
+
+&#x20;      ↓ Employments(\*\*o) 实例化
+
+&#x20;      ↓ db.add → db.commit → db.refresh
+
+&#x20;      ↓ 失败 → db.rollback → 返回 500
+```
+
+### 更新流程（PUT /emp?id=X）
+
+
+
+```
+前端 → CURD\_api.updata\_stuinfo()
+
+&#x20;      ↓ 请求体排除未传字段（exclude\_unset）
+
+&#x20;      ↓ 为空 → 400「没有需要更新的字段」
+
+&#x20;      ↓ update\_emp\_dao() 按 id 执行 update
+
+&#x20;      ↓ 影响 0 行 → 404「未找到对应记录」
+```
+
+### 删除流程（DELETE /emp/{id}）
+
+
+
+```
+前端 → CURD\_api.delete\_stuinfo()
+
+&#x20;      ↓ delete\_emp\_dao() 按 id 执行 UPDATE is\_deleted = 1（软删除）
+
+&#x20;      ↓ 影响 0 行 → 500「没有删除」
+```
+
+## 六、项目亮点
+
+
+
+1. **清晰的分层架构**
+
+   路由（CURD\_api.py）、数据访问（dao.py）、模型（model.py）、校验（request.py）各司其职，便于单元测试与维护。
+
+2. **全链路软删除**
+
+   Employments、Company、Address 三张表均有 `is_deleted` 字段，删除统一走 `UPDATE is_deleted = 1`，数据可追溯、可恢复；查询时统一过滤 `is_deleted == 0`。
+
+3. **动态多条件组合查询**
+
+   `get_emp_dao` 使用链式 filter 动态拼接查询条件，任一条件为空自动跳过，一个接口覆盖 10 种查询维度（姓名 / 班级 / 公司 / 薪资区间 / 地址 / 开放时间区间 / Offer 时间区间）。
+
+4. **统一时间戳审计**
+
+   所有表均带 `create_time` / `update_time`，`onupdate=datetime.now` 让修改自动记录时间，为审计、报表提供数据基础。
+
+5. **请求体与响应体分离**
+
+   request.py 为每类资源定义独立请求体（PostRequest / CompRequest / AddRequest）与响应体（EmpResponse / CompResponse / AddResponse），前端契约清晰，Swagger 自动生成接口文档。
+
+6. **多表 JOIN 关联查询**
+
+   就业记录与学生、班级、公司、地址四张表通过外键关联，一次查询即可返回完整就业信息，无需前端二次请求。
+
+7. **外键约束保证数据完整性**
+
+   stuid /class\_id/company\_id /address\_id 全部建立外键，杜绝 "就业记录指向不存在学生 / 公司" 的脏数据。
+
+## 七、待添加的新功能 与 已知问题
+
+### 🎯 短期（可快速落地）
+
+
+
+| 功能      | 说明                                               | 涉及改动                                           |
+| ------- | ------------------------------------------------ | ---------------------------------------------- |
+| 分页查询    | /emp 支持 page /page\_size，返回 total 与 items        | dao.py 加 .offset ().limit ()，request.py 加分页请求体 |
+| 薪资区间校验  | 确保 min\_salary <= max\_salary                    | request.py 加 @model\_validator                 |
+| 数据去重    | 同一学生同一公司只保留一条有效就业记录                              | add\_employment\_dao 前置查询 + 唯一约束               |
+| 级联删除    | 删公司 / 地址时同步软删其下就业记录                              | dao.py 加级联更新逻辑                                 |
+| 外键存在性校验 | 新增时校验 stuid /company\_id/address\_id 真实存在，给出明确错误 | dao.py 前置查询                                    |
+
+### 🚀 中期（需要设计）
+
+
+
+| 功能         | 说明                                |
+| ---------- | --------------------------------- |
+| 批量导入       | 支持 Excel/CSV 批量导入就业信息             |
+| 数据导出       | 查询结果一键导出为 Excel                   |
+| JWT 鉴权     | 管理员 / 普通用户角色分离，保护写接口              |
+| 操作日志       | 记录每一次增删改操作的操作人与时间                 |
+| Alembic 迁移 | 用 Alembic 管理表结构变更，告别手动 DROP TABLE |
+
+### 🌟 长期（数据价值）
+
+
+
+| 功能     | 说明                      |
+| ------ | ----------------------- |
+| 就业数据看板 | 按班级 / 公司 / 薪资维度统计，前端可视化 |
+| 薪资分布分析 | 直方图、分位数、同比环比            |
+| 就业率追踪  | 结合学生表计算班级 / 专业就业率       |
+| 缓存层    | Redis 缓存 Top5、统计类接口     |
+| 异步任务   | Celery 处理导入 / 导出等耗时任务   |
+
+### ⚠️ 当前已知问题（开发中待修复）
+
+
+
+| 问题                | 位置                                                       | 影响                   | 建议修复                      |
+| ----------------- | -------------------------------------------------------- | -------------------- | ------------------------- |
+| 查询结果按 5 变量解包 3 元组 | dao.py get\_emp\_dao                                     | 查到数据即 ValueError 崩溃  | select 补齐 5 列，或解包变量与列数一致  |
+| 空日期直接 strftime    | dao.py 返回段                                               | 时间为空时 AttributeError | 判空后再格式化                   |
+| 删除 0 行返回 500      | CURD\_api.py delete\_stuinfo                             | 状态码语义错误              | 改 404                     |
+| 查询空结果返回 404       | CURD\_api.py get\_stuinfo                                | 正常空结果被当异常            | 改 200 + 空列表 + totals      |
+| 更新未过滤已删除记录        | dao.py update\_emp\_dao                                  | 可修改已软删数据             | filter 加 is\_deleted == 0 |
+| SQL 全量打印          | database.py echo=True                                    | 开发噪音 / 性能损耗          | 生产环境关闭                    |
+| 命名不统一             | Shtudent\_Jiuye / updata\_stuinfo / offer\_recived\_time | 可读性差                 | 统一规范命名                    |
+
+## 八、运行方式
+
+
+
+```
+\# 1. 安装依赖
+
+pip install fastapi uvicorn sqlalchemy pymysql pydantic python-dotenv
+
+\# 2. 配置数据库（项目根目录 .env 中 DB\_USER / DB\_PASSWORD / DB\_HOST / DB\_PORT / DB\_NAME）
+
+\# 3. 启动服务（根入口，含全模块）
+
+python main.py
+
+\# 或
+
+uvicorn main:app --host 127.0.0.1 --port 59000 --reload
+
+\# 4. 单独调试就业模块
+
+uvicorn stu\_jiuye.main:app --host 127.0.0.1 --port 12395 --reload
+
+\# 5. 访问 Swagger 文档
+
+http://127.0.0.1:59000/docs
+```
+
+## 九、注意事项
+
+
+
+1. **表结构变更需删表重建**：`Base.metadata.create_all(engine)` 只建不改，模型加字段后需 DROP TABLE 或引入 Alembic。
+
+2. **建表时机**：当前建表逻辑在根 `../main.py` 的 `__main__` 块中执行；直接用 `uvicorn main:app` 启动时不会建表，全新环境需先执行一次 `python main.py`（或后续将建表移入 FastAPI lifespan）。
+
+3. **添加顺序有外键依赖**：先建学生 / 班级 / 公司 / 地址，再添加就业记录；Employments 的 stuid /class\_id/company\_id /address\_id 均受外键约束。
+
+4. **软删除后查询自动过滤**：`get_emp_dao` 已统一过滤 `is_deleted == 0`，被删除的记录不会再出现在列表里。
+
+5. **删除接口用 Path 参数**：`DELETE /emp/{id}`，不要写成 `/emp?id=X`。
+
+6. **echo=True 仅限开发**：生产环境请关掉，避免刷屏与性能损耗。

stu_jiuye/就业模块文档11.md

@@ -0,0 +1,270 @@
+# 学生就业信息管理系统 —— 就业模块项目文档
+
+## 一、模块概述
+
+本模块是「学生就业信息管理系统」的核心业务模块，负责管理学生就业状态的全生命周期。围绕就业信息（Employments）、公司信息（Company）、地址信息（Address）三张核心表，并与学生表（students）、班级表（classes）建立外键关联，提供增删改查（CRUD）与统计分析接口。
+
+**技术栈：**
+
+| 项 | 选型 |
+|---|---|
+| Web 框架 | FastAPI |
+| ORM | SQLAlchemy 2.x |
+| 数据库 | MySQL 8.x（驱动 PyMySQL） |
+| 数据校验 | Pydantic v2 |
+| 服务启动 | Uvicorn |
+
+## 二、目录结构
+
+```
+student_manage_system/
+├── main.py                # 程序入口：注册全模块路由、建表（__main__ 中执行）
+├── databases.py           # 根数据库配置：engine_all / Base_all / Session / get_db
+└── stu_jiuye/             # 就业模块业务包
+    ├── main.py            # 路由组装（Shtudent_Jiuye）；独立自测 app
+    ├── database.py        # 模块级数据库配置（engine / Base / Session / get_db）
+    ├── model.py           # ORM 模型：Employments / Company / Address
+    ├── request.py         # Pydantic 请求体 / 响应体模型
+    ├── dao.py             # 数据访问层（纯数据库操作）
+    └── CURD_api.py        # 路由层（API 接口定义）
+```
+
+**分层职责：**
+
+| 层 | 文件 | 职责 |
+|---|---|---|
+| 路由层 | CURD_api.py | 接收 HTTP 请求，参数校验，调用 DAO，返回响应 |
+| 数据访问层 | dao.py | 封装 SQLAlchemy 查询与事务，向上提供函数 |
+| 模型层 | model.py | 定义表结构与外键关系 |
+| 校验层 | request.py | 定义请求体 / 响应体的字段与类型 |
+| 配置层 | database.py | 数据库 URL、引擎、Session 工厂 |
+
+## 三、数据表设计
+
+### 1. Employments（就业信息表）
+
+| 字段 | 类型 | 约束 | 说明 |
+|---|---|---|---|
+| id | Integer | PK, 自增 | 主键 |
+| stuid | Integer | FK → students.id | 学生 ID |
+| class_id | Integer | FK → classes.id | 班级 ID |
+| company_id | Integer | FK → Company.id, 可空 | 就业公司 |
+| address_id | Integer | FK → Address.id, NOT NULL | 就业地址 |
+| employment_salary | Integer | 可空 | 就业薪资 |
+| employment_open_time | DATE | 可空 | 就业开放时间 |
+| offer_recived_time | DATE | 可空 | Offer 下发时间 |
+| create_time | DateTime | default=now | 创建时间 |
+| update_time | DateTime | default=now, onupdate=now | 更新时间 |
+| is_deleted | Integer | default=0 | 软删除标记（0 正常 / 1 已删） |
+
+### 2. Company（公司表）
+
+| 字段 | 类型 | 约束 | 说明 |
+|---|---|---|---|
+| id | Integer | PK, 自增 | 主键 |
+| employment_company | String(50) | NOT NULL | 公司名称 |
+| create_time | DateTime | default=now | 创建时间 |
+| update_time | DateTime | default=now, onupdate=now | 更新时间 |
+| is_deleted | Integer | default=0 | 软删除标记 |
+
+### 3. Address（地址表）
+
+| 字段 | 类型 | 约束 | 说明 |
+|---|---|---|---|
+| id | Integer | PK, 自增 | 主键 |
+| somewhere | String(50) | NOT NULL | 地址区域，如"深圳市南山区" |
+| create_time | DateTime | default=now | 创建时间 |
+| update_time | DateTime | default=now, onupdate=now | 更新时间 |
+| is_deleted | Integer | default=0 | 软删除标记 |
+
+### 表关系图
+
+```
+students (1) ───< (N) Employments (N) >─── (1) Company
+classes  (1) ───< (N)         |  (N) >─── (1) Address
+```
+
+- 一个学生可有多个就业记录，一条就业记录对应一个学生（通过 stuid 关联学生表）
+- 一条就业记录对应一个公司（company_id）与一个地址（address_id）
+- 通过多表 JOIN 可从就业记录直接获取学生姓名、班级名称、公司名称与地址信息
+
+**设计说明：姓名/班级不冗余，走 JOIN 获取**
+
+与"在就业表冗余学生姓名"的方案不同，本模块选择通过 `stuid`、`class_id` 外键关联学生表与班级表，查询时动态 JOIN 获取姓名与班级名。代价是查询多一次 JOIN；好处是学生姓名/班级变更后无需同步，数据天然一致。
+
+## 四、API 功能清单（CRUD）
+
+接口定义于 `stu_jiuye/CURD_api.py` 的 `CURD` 路由，由根 `main.py` 以 `Shtudent_Jiuye` 挂载。
+
+### 📌 新增（Create）
+
+| 方法 | 路径 | 功能 | 请求体 |
+|---|---|---|---|
+| POST | /emp/company/address | 新增地址区域 | AddRequest |
+| POST | /emp/company | 新增公司 | CompRequest |
+| POST | /emp | 新增学生就业信息 | PostRequest |
+
+> 注意：由于外键依赖，建议按 Address → Company → Employments 的顺序添加。
+
+### 📌 查询（Read）
+
+| 方法 | 路径 | 功能 | 查询参数 |
+|---|---|---|---|
+| GET | /emp | 多条件查询就业信息 | sname、class_id、employment_company、min_salary、max_salary、somewhere、employment_open_start、employment_open_end、offer_recived_start、offer_recived_end（全部可选，均不传则查询全部） |
+
+> 就业薪资 Top5、就业时长、平均就业时长等统计接口已迁移至统计分析模块（StatCalc）：`/statcalc/top`、`/statcalc/job`、`/statcalc/avgjob`。
+
+### 📌 更新（Update）
+
+| 方法 | 路径 | 功能 | 参数 |
+|---|---|---|---|
+| PUT | /emp?id=X | 修改就业信息 | Query：id；Body：PostRequest（支持部分字段更新） |
+
+### 📌 删除（Delete）
+
+| 方法 | 路径 | 功能 | 参数 |
+|---|---|---|---|
+| DELETE | /emp/{id} | 软删除就业信息 | Path：id |
+
+**删除说明**：本模块采用软删除（`is_deleted = 1`），数据不会从物理表中移除，便于审计与恢复。
+
+## 五、核心流程示例
+
+### 查询流程（GET /emp）
+
+```
+前端 → CURD_api.get_stuinfo()
+       ↓ 收集 10 个可选查询条件
+       ↓ 调用 get_emp_dao()
+       ↓ DAO 五表 OUTER JOIN：Employments + Students + ClassInfo + Company + Address
+       ↓ 动态拼接 filter（姓名/班级/公司/薪资范围/地址/时间范围）
+       ↓ 统一过滤 is_deleted = 0
+       ↓ 返回 list[dict]（含学生姓名、班级名称、公司、区域、薪资、时间）
+       ↓ 结果为空 → 404「名单不存在」
+```
+
+### 添加流程（POST /emp）
+
+```
+前端 → CURD_api.add_stuinfo()
+       ↓ p.model_dump() 转 dict
+       ↓ add_employment_dao()
+       ↓ o.pop('id' / 'create_time' / 'update_time' / 'is_deleted') 去掉自增主键与自动字段
+       ↓ Employments(**o) 实例化
+       ↓ db.add → db.commit → db.refresh
+       ↓ 失败 → db.rollback → 返回 500
+```
+
+### 更新流程（PUT /emp?id=X）
+
+```
+前端 → CURD_api.updata_stuinfo()
+       ↓ 请求体排除未传字段（exclude_unset）
+       ↓ 为空 → 400「没有需要更新的字段」
+       ↓ update_emp_dao() 按 id 执行 update
+       ↓ 影响 0 行 → 404「未找到对应记录」
+```
+
+### 删除流程（DELETE /emp/{id}）
+
+```
+前端 → CURD_api.delete_stuinfo()
+       ↓ delete_emp_dao() 按 id 执行 UPDATE is_deleted = 1（软删除）
+       ↓ 影响 0 行 → 500「没有删除」
+```
+
+## 六、项目亮点
+
+1. **清晰的分层架构**
+   路由（CURD_api.py）、数据访问（dao.py）、模型（model.py）、校验（request.py）各司其职，便于单元测试与维护。
+
+2. **全链路软删除**
+   Employments、Company、Address 三张表均有 `is_deleted` 字段，删除统一走 `UPDATE is_deleted = 1`，数据可追溯、可恢复；查询时统一过滤 `is_deleted == 0`。
+
+3. **动态多条件组合查询**
+   `get_emp_dao` 使用链式 filter 动态拼接查询条件，任一条件为空自动跳过，一个接口覆盖 10 种查询维度（姓名/班级/公司/薪资区间/地址/开放时间区间/Offer 时间区间）。
+
+4. **统一时间戳审计**
+   所有表均带 `create_time` / `update_time`，`onupdate=datetime.now` 让修改自动记录时间，为审计、报表提供数据基础。
+
+5. **请求体与响应体分离**
+   request.py 为每类资源定义独立请求体（PostRequest / CompRequest / AddRequest）与响应体（EmpResponse / CompResponse / AddResponse），前端契约清晰，Swagger 自动生成接口文档。
+
+6. **多表 JOIN 关联查询**
+   就业记录与学生、班级、公司、地址四张表通过外键关联，一次查询即可返回完整就业信息，无需前端二次请求。
+
+7. **外键约束保证数据完整性**
+   stuid / class_id / company_id / address_id 全部建立外键，杜绝"就业记录指向不存在学生/公司"的脏数据。
+
+## 七、待添加的新功能 与 已知问题
+
+### 🎯 短期（可快速落地）
+
+| 功能 | 说明 | 涉及改动 |
+|---|---|---|
+| 分页查询 | /emp 支持 page / page_size，返回 total 与 items | dao.py 加 .offset().limit()，request.py 加分页请求体 |
+| 薪资区间校验 | 确保 min_salary <= max_salary | request.py 加 @model_validator |
+| 数据去重 | 同一学生同一公司只保留一条有效就业记录 | add_employment_dao 前置查询 + 唯一约束 |
+| 级联删除 | 删公司/地址时同步软删其下就业记录 | dao.py 加级联更新逻辑 |
+| 外键存在性校验 | 新增时校验 stuid / company_id / address_id 真实存在，给出明确错误 | dao.py 前置查询 |
+
+### 🚀 中期（需要设计）
+
+| 功能 | 说明 |
+|---|---|
+| 批量导入 | 支持 Excel/CSV 批量导入就业信息 |
+| 数据导出 | 查询结果一键导出为 Excel |
+| JWT 鉴权 | 管理员 / 普通用户角色分离，保护写接口 |
+| 操作日志 | 记录每一次增删改操作的操作人与时间 |
+| Alembic 迁移 | 用 Alembic 管理表结构变更，告别手动 DROP TABLE |
+
+### 🌟 长期（数据价值）
+
+| 功能 | 说明 |
+|---|---|
+| 就业数据看板 | 按班级/公司/薪资维度统计，前端可视化 |
+| 薪资分布分析 | 直方图、分位数、同比环比 |
+| 就业率追踪 | 结合学生表计算班级/专业就业率 |
+| 缓存层 | Redis 缓存 Top5、统计类接口 |
+| 异步任务 | Celery 处理导入/导出等耗时任务 |
+
+### 
+
+|      |      |      |      |
+|---|---|---|---|
+|      |      |      |      |
+|      |      |      |      |
+|      |      |      |      |
+|      |      |      |      |
+|      |      |      |      |
+|      |      |      |      |
+|      |      |      |  |
+
+## 八、运行方式
+
+```bash
+# 1. 安装依赖
+pip install fastapi uvicorn sqlalchemy pymysql pydantic python-dotenv
+
+# 2. 配置数据库（项目根目录 .env 中 DB_USER / DB_PASSWORD / DB_HOST / DB_PORT / DB_NAME）
+
+# 3. 启动服务（根入口，含全模块）
+python main.py
+# 或
+uvicorn main:app --host 127.0.0.1 --port 59000 --reload
+
+# 4. 单独调试就业模块
+uvicorn stu_jiuye.main:app --host 127.0.0.1 --port 12395 --reload
+
+# 5. 访问 Swagger 文档
+http://127.0.0.1:59000/docs
+```
+
+## 九、注意事项
+
+1. **表结构变更需删表重建**：`Base.metadata.create_all(engine)` 只建不改，模型加字段后需 DROP TABLE 或引入 Alembic。
+2. **建表时机**：当前建表逻辑在根 `main.py` 的 `__main__` 块中执行；直接用 `uvicorn main:app` 启动时不会建表，全新环境需先执行一次 `python main.py`（或后续将建表移入 FastAPI lifespan）。
+3. **添加顺序有外键依赖**：先建学生/班级/公司/地址，再添加就业记录；Employments 的 stuid / class_id / company_id / address_id 均受外键约束。
+4. **软删除后查询自动过滤**：`get_emp_dao` 已统一过滤 `is_deleted == 0`，被删除的记录不会再出现在列表里。
+5. **删除接口用 Path 参数**：`DELETE /emp/{id}`，不要写成 `/emp?id=X`。
+6. **echo=True 仅限开发**：生产环境请关掉，避免刷屏与性能损耗。

students/api/students_api.py

@@ -27,15 +27,15 @@ def get_students( stu:StudentsQuery = Depends()
 @s_api.post("/students"
     ,summary='新增学生资料'
     ,description=f'学生ID自动分配，学生姓名、学生手机号和班级是必填项，不能为空。\n '
-                 f'时间格式：YYYY-MM-DD'
+                 f'注意事项：\n'
+                 f'时间格式：YYYY-MM-DD\n'
+                 f'班级ID和顾问ID必须已经存在才可以绑定'
     ,response_model=StudentsResponse )
 def add_student( stu:StudentsResponse = Depends()
                 , db=Depends(get_db)
                  ):
     s_dict = stu.model_dump(exclude_unset=True)
     result = add_student_dao( s=s_dict , db=db )
-    if not result:
-        raise HTTPException(status_code=500, detail='手机号已有学生使用或必填项为空。')
     return result
 
 @s_api.put("/students"

students/dao/students_dao.py

@@ -62,9 +62,11 @@ def add_student_dao( s , db):
         phone = s.get("phone")
         s1_deleted = db.query( Students ).filter( Students.phone == phone ).first()
         if s1_deleted and s1_deleted.is_deleted == False:
-            return False
+            raise ValueError("该手机号已存在有效学生记录，请勿重复添加")
         if not phone:
-            return False
+            raise ValueError("手机号不能为空")
+        if not s.get("class_id") or not s.get("advisor_id"):
+            raise ValueError("班级ID和顾问ID必须已经存在才可以绑定")
         if s1_deleted and s1_deleted.is_deleted == True:
             s1_deleted.name = s.get("name")
             s1_deleted.age = s.get("age")
@@ -90,10 +92,14 @@ def add_student_dao( s , db):
             return s1_deleted
         s1 = Students( **s )
         db.add(s1)
+    except ValueError as e:
+        # 业务校验异常：回滚并返回错误信息
+        db.rollback()
+        return {"code": 400, "msg": str(e)}
     except Exception:
         # 这里可以加日志
         db.rollback()
-        return False
+        return {"code": 500, "msg": f"系统异常: {str(e)}"}
     else:
         db.commit()
         db.refresh(s1)