学生信息管理系统（简化版）后端接口

不太爱喝水2024-12-09 15:19

目录

allAPI

init.py是空文件，目的让python知道这个文件夹是个包

ClassInfo.py

python 复制代码 
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from API.database import get_db, Base
from sqlalchemy import Column, String, Integer

app04 = APIRouter()

# 定义班级信息模型
class ClassInfo(Base):
    __tablename__ = 'ClassInfo'
    class_id = Column(String(40), primary_key=True, nullable=False)
    cls_rank = Column(String(40), nullable=False)
    head_teacher = Column(String(40), nullable=False)
    student_count = Column(Integer, nullable=False)

# 定义班级信息视图模型
class ViewClassInfo(Base):
    __tablename__ = 'ViewClassInfo'
    class_id = Column(String(40), primary_key=True)
    cls_rank = Column(String(40))
    head_teacher = Column(String(40))
    student_count = Column(Integer)

# 获取班级信息列表
@app04.get("/classes")
async def read_classes(db: Session = Depends(get_db)):
    try:
        classes = db.query(ViewClassInfo).all()
        if classes:
            return {"success": True, "data": classes}
        else:
            return {"success": True, "data": [], "message": "No data available"}
    except Exception as e:
        return {"success": False, "message": "Failed to fetch classes", "error": str(e)}


from pydantic import BaseModel

# 定义用于接收班级ID列表的 Pydantic 模型
class ClassIds(BaseModel):
    class_ids: list

# 删除班级信息
@app04.delete("/classes")
async def delete_classes(data: ClassIds, db: Session = Depends(get_db)):
    not_found_ids = []  # 用于存储不存在的班级ID
    try:
        for class_id in data.class_ids:  # 从模型中提取班级ID列表
            class_info = db.query(ClassInfo).filter(ClassInfo.class_id == class_id).first()
            if class_info:
                db.delete(class_info)
            else:
                not_found_ids.append(class_id)  # 如果班级ID不存在，添加到列表中
        if not_found_ids:
            raise HTTPException(status_code=404, detail=f"班级ID不存在: {', '.join(not_found_ids)}")
        db.commit()
        return {"success": True, "message": "删除成功"}
    except Exception as e:
        db.rollback()
        return {"success": False, "message": "删除失败", "error": str(e)}


# 定义用于接收班级信息的 Pydantic 模型
class ClassInfoModel(BaseModel):
    class_id: str
    cls_rank: str
    head_teacher: str
    student_count: int

# 添加班级信息
@app04.post("/classes")
async def add_class(data: ClassInfoModel, db: Session = Depends(get_db)):
    try:
        # 检查班级ID是否已存在
        existing_class = db.query(ClassInfo).filter(ClassInfo.class_id == data.class_id).first()
        if existing_class:
            raise HTTPException(status_code=400, detail="班级ID已存在")

        # 添加新班级信息
        new_class = ClassInfo(
            class_id=data.class_id,
            cls_rank=data.cls_rank,
            head_teacher=data.head_teacher,
            student_count=data.student_count
        )
        db.add(new_class)
        db.commit()
        return {"success": True, "message": "添加成功"}
    except HTTPException as e:
        # 直接将HTTPException的详情返回给前端
        return {"success": False, "message": "添加失败", "error": str(e)}
    except Exception as e:
        db.rollback()
        return {"success": False, "message": "添加失败", "error": str(e)}

enrollment_api.py

python 复制代码 
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel
from API.database import get_db, Base
from sqlalchemy import Column, String, Date


# 创建API路由
app03 = APIRouter()


# 定义学生学籍信息模型
class StudentEnrollment(Base):
    __tablename__ = 'StudentEnrollment'

    student_id = Column(String(8), primary_key=True, nullable=False)
    stu_name = Column(String(8), nullable=False)
    gender = Column(String(6), nullable=False)
    class_ = Column(String(20), nullable=False)
    birth_date = Column(String(80), nullable=False)
    school = Column(String(200), nullable=False)

# 创建视图模型
class ViewStudentEnrollment(Base):
    __tablename__ = 'ViewStudentEnrollment'

    student_id = Column(String(8), primary_key=True)
    stu_name = Column(String(8))
    gender = Column(String(6))
    class_ = Column(String(20))
    birth_date = Column(String(80))
    school = Column(String(200))

# 定义用于接收学生信息的 Pydantic 模型
class StudentEnrollmentModel(BaseModel):
    student_id: str
    stu_name: str
    gender: str
    class_: str
    birth_date: str
    school: str

# 获取学生学籍信息列表
@app03.get("/enrollments")
async def read_enrollments(db: Session = Depends(get_db)):
    try:
        enrollments = db.query(ViewStudentEnrollment).all()
        if enrollments:
            return {"success": True, "data": enrollments}
        else:
            return {"success": True, "data": [], "message": "No data available"}
    except Exception as e:
        return {"success": False, "message": "Failed to fetch enrollments", "error": str(e)}


# 定义用于接收学号列表的 Pydantic 模型
class StudentIds(BaseModel):
    student_ids: list

# 删除学生学籍信息
@app03.delete("/enrollments")
async def delete_enrollments(data: StudentIds, db: Session = Depends(get_db)):
    not_found_ids = []  # 用于存储不存在的学号
    try:
        for student_id in data.student_ids:  # 从模型中提取学号列表
            enrollment = db.query(StudentEnrollment).filter(StudentEnrollment.student_id == student_id).first()
            if enrollment:
                db.delete(enrollment)
            else:
                not_found_ids.append(student_id)  # 如果学号不存在，添加到列表中
        if not_found_ids:
            raise HTTPException(status_code=404, detail=f"学号不存在: {', '.join(not_found_ids)}")
        db.commit()
        return {"success": True, "message": "删除成功"}
    except Exception as e:
        db.rollback()
        return {"success": False, "message": "删除失败", "error": str(e)}

# 添加学生学籍信息
@app03.post("/enrollments")
async def add_enrollment(data: StudentEnrollmentModel, db: Session = Depends(get_db)):
    try:
        # 检查学号是否已存在
        existing_enrollment = db.query(StudentEnrollment).filter(StudentEnrollment.student_id == data.student_id).first()
        if existing_enrollment:
            raise HTTPException(status_code=400, detail="学号已存在")

        # 添加新学生学籍信息
        new_enrollment = StudentEnrollment(
            student_id=data.student_id,
            stu_name=data.stu_name,
            gender=data.gender,
            class_=data.class_,
            birth_date=data.birth_date,
            school=data.school
        )
        db.add(new_enrollment)
        db.commit()
        return {"success": True, "message": "添加成功"}
    except HTTPException as e:
        # 直接将HTTPException的详情返回给前端
        return {"success": False, "message": "添加失败", "error": str(e)}
    except Exception as e:
        db.rollback()
        return {"success": False, "message": "添加失败", "error": str(e)}

LoginANDEnroll.py

python 复制代码 
from fastapi import FastAPI, HTTPException, status, Request, APIRouter, Depends
from pydantic import BaseModel
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from API.database import SessionLocal, User, get_db  # 从 database.py 导入 SessionLocal, User 和 get_db



from sqlalchemy.orm import Session
from datetime import datetime


app01 = APIRouter()


# # 创建数据库连接字符串
# SQLALCHEMY_DATABASE_URL = "mysql+mysqlconnector://root:123456@localhost/datas"
# engine = create_engine(SQLALCHEMY_DATABASE_URL)
#
# # 创建会话本地工厂
# SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
#
# # 创建声明式基类
# Base = declarative_base()


# 定义用户模型
# class User(Base):
#     __tablename__ = "users"
#
#     id = Column(Integer, primary_key=True, index=True)
#     username = Column(String(50), unique=True, index=True)
#     password = Column(String(50))
#     registration_date = Column(DateTime)
#     is_admin = Column(Boolean, default=False)  # 添加一个字段来判断是否为管理员


# 创建数据库表
# Base.metadata.create_all(bind=engine)


# # 创建一个依赖项函数来管理数据库会话
# def get_db():
#     db = SessionLocal()
#     try:
#         yield db
#     finally:
#         db.close()

# 用户登录请求模型
class Login(BaseModel):
    username: str
    password: str


# 登录接口
@app01.post("/login")
async def login(login: Login, db: Session = Depends(get_db)):
    if not login.username or not login.password:
        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="用户名和密码不能为空")

    # session = SessionLocal()
    user = db.query(User).filter(User.username == login.username).first()

    if user and user.password == login.password:
        return {"success": True, "user_type": "admin" if user.is_admin else "user"}
    else:
        return {"success": False}  # 返回一个标准的 JSON 响应


# 用户注册请求模型
class Register(BaseModel):
    username: str
    password: str


# 然后在路由函数中使用这个依赖项
@app01.post("/register")
async def register(user: Register, db: Session = Depends(get_db)):
    # 检查用户是否已存在
    existing_user = db.query(User).filter(User.username == user.username).first()
    if existing_user:
        return {"success": False, "message": "用户已存在"}

    # 创建新用户
    new_user = User(
        username=user.username,
        password=user.password,  # 在实际应用中，应该对密码进行哈希处理
        registration_date=datetime.now()
    )
    db.add(new_user)
    db.commit()
    db.refresh(new_user)
    return {"success": True, "message": "注册成功", "user_id": new_user.id}






# # 定义生命周期事件处理器，事件处理器不能写在这
# async def shutdown_event(app: FastAPI) -> None:
#     await SessionLocal.close_all()
#
#
# # 注册事件处理器
# app01.add_event_handler("shutdown", shutdown_event)

# # 运行应用
# if __name__ == "__main__":
#     import uvicorn
#
#     uvicorn.run(app, host="localhost", port=8000)
#     # uvicorn.run(app, host="localhost", port=63342)

student_scores.pr

python 复制代码 
from fastapi import APIRouter, HTTPException, Depends
from sqlalchemy.orm import Session
from API.database import get_db, Base
from sqlalchemy import Column, Integer, String

app02 = APIRouter()

# 定义学生成绩模型
class StudentScoreFromView(Base):
    __tablename__ = 'StudentScoresWithTotalRank'

    student_id = Column(String, primary_key=True)
    stu_name = Column(String)
    total_score = Column(Integer)
    score_rank = Column(Integer)
    class_ = Column(String)  # 注意这里使用 class_ 而不是 class，因为 class 是 Python 的保留字

# 新模型，引用实际的 StudentScores 表
class StudentScore(Base):
    __tablename__ = 'StudentScores'
    student_id = Column(String, primary_key=True)
    stu_name = Column(String)
    total_score = Column(Integer)
    score_rank = Column(Integer)
    class_ = Column(String)  # 使用 class_ 避免与 Python 关键字冲突

# 获取学生成绩列表
@app02.get("/studentscores")
async def read_student_scores(db: Session = Depends(get_db)):
    try:
        scores = db.query(StudentScoreFromView).all()
        if scores:
            return {"success": True, "data": scores}
        else:
            return {"success": True, "data": [], "message": "No data available"}
    except Exception as e:
        return {"success": False, "message": "Failed to fetch scores", "error": str(e)}


from pydantic import BaseModel

# 定义用于接收学号列表的 Pydantic 模型
class StudentIds(BaseModel):
    student_ids: list

# 删除学生成绩
from fastapi import HTTPException

@app02.delete("/studentscores")
async def delete_student_scores(data: StudentIds, db: Session = Depends(get_db)):
    not_found_ids = []  # 用于存储不存在的学号
    try:
        for student_id in data.student_ids:  # 从模型中提取学号列表
            student_score = db.query(StudentScore).filter(StudentScore.student_id == student_id).first()
            if student_score:
                db.delete(student_score)
            else:
                not_found_ids.append(student_id)  # 如果学号不存在，添加到列表中
        if not_found_ids:
            raise HTTPException(status_code=404, detail=f"学号不存在: {', '.join(not_found_ids)}")
        db.commit()
        return {"success": True, "message": "删除成功"}
    except Exception as e:
        db.rollback()
        return {"success": False, "message": "删除失败", "error": str(e)}

# 定义用于接收学生信息的 Pydantic 模型
class StudentScoreModel(BaseModel):
    student_id: str
    stu_name: str
    total_score: int
    score_rank: int
    class_: str


# 添加学生成绩
@app02.post("/studentscores")
async def add_student_score(data: StudentScoreModel, db: Session = Depends(get_db)):
    try:
        # 检查学号是否已存在
        existing_student = db.query(StudentScore).filter(StudentScore.student_id == data.student_id).first()
        if existing_student:
            raise HTTPException(status_code=400, detail="学号已存在")

        # 添加新学生成绩
        new_student = StudentScore(
            student_id=data.student_id,
            stu_name=data.stu_name,
            total_score=data.total_score,
            score_rank=data.score_rank,
            class_=data.class_
        )
        db.add(new_student)
        db.commit()
        return {"success": True, "message": "添加成功"}
    except HTTPException as e:
        # 直接将HTTPException的详情返回给前端
        return {"success": False, "message": "添加失败", "error": str(e)}
    except Exception as e:
        db.rollback()
        return {"success": False, "message": "添加失败", "error": str(e)}

database.py

创建数据库连接字符串

SQLALCHEMY_DATABASE_URL = "mysql+mysqlconnector://root:123456@localhost/datas"

engine = create_engine(SQLALCHEMY_DATABASE_URL)

此部分需连接自己的mysql

python 复制代码 
from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# 创建数据库连接字符串
SQLALCHEMY_DATABASE_URL = "mysql+mysqlconnector://root:123456@localhost/datas"
engine = create_engine(SQLALCHEMY_DATABASE_URL)

# 创建会话本地工厂
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# 创建声明式基类
Base = declarative_base()

# 定义用户模型
class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String(50), unique=True, index=True)
    password = Column(String(50))
    registration_date = Column(DateTime)
    is_admin = Column(Boolean, default=False)  # 添加一个字段来判断是否为管理员

# 创建数据库表
Base.metadata.create_all(bind=engine)

# 创建一个依赖项函数来管理数据库会话
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

main.py

python 复制代码 
from fastapi import FastAPI
import uvicorn
from fastapi.staticfiles import StaticFiles
from fastapi.middleware.cors import CORSMiddleware

from database import SessionLocal
from allAPI.LoginANDEnroll import app01
from allAPI.student_scores import app02
from allAPI.enrollment_api import app03
from allAPI.ClassInfo import app04

app = FastAPI()

# 添加 CORS 中间件
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],  # 允许所有源
    allow_credentials=True,
    allow_methods=["*"],  # 允许所有方法
    allow_headers=["*"],  # 允许所有头
)


app.include_router(app01, prefix="/WJH", tags=["登录与注册"])
app.include_router(app02, prefix="/WJH", tags=["成绩信息"])
app.include_router(app03, prefix="/WJH", tags=["学籍信息"])
app.include_router(app04, prefix="/WJH", tags=["班级信息"])

# 定义生命周期事件处理器
async def shutdown_event(app: FastAPI) -> None:
    await SessionLocal.close_all()

# 注册事件处理器
app.add_event_handler("shutdown", shutdown_event)


if __name__ == '__main__':
    uvicorn.run("main:app", port=8000, reload=True, host="127.0.0.1")
    # uvicorn.run("main:app", port=8000, reload=True, host="localhost")

前端链接：学生信息管理系统（简化版）-CSDN博客

数据库链接：学生信息管理系统（简化版）数据库部分-CSDN博客

相关推荐
伊一大数据&人工智能学习日志1 分钟前
Python爬虫——HTML中Xpath定位
爬虫·python·html
web136885658718 分钟前
Spring Boot 中使用 @Transactional 注解配置事务管理
数据库·spring boot·sql
fendouweiqian1 小时前
python请求SSL问题
网络·python·ssl
骷大人1 小时前
mysql开启配置binlog
数据库·mysql
Yolo_nn1 小时前
MySQL_第14章_存储过程与函数
数据库·mysql·存储过程·函数
GDDGHS_1 小时前
Flink自定义数据源
大数据·数据库·flink
fuvuof1 小时前
设计模式——单例模式和工厂模式
python·单例模式·设计模式
东方佑2 小时前
给图像去除水印攻
人工智能·python
Milk夜雨2 小时前
数据库进阶教程：结合编程实现动态数据操作
数据库·python·adb
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02【halcon】halcon字符识别——OCR03玄机平台应急响应—webshell查杀04Windows11 Copilot助手开启教程(免费GPT-4)0504 - matlab m_map地学绘图工具基础函数 - 设置网格06Docker 夺命连环 15 问07【一文读懂】NTN（非地面网络）技术介绍08支付宝短视频平台创作分成激励项目09PyTorch机器学习实现液态神经网络10『手写ahooks系列-useClickAway』一个hook解决监听点击元素外部