在线教学管理小程序开发文档

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `username` varchar(255) NOT NULL COMMENT '用户名',
  `password` varchar(255) NOT NULL COMMENT '密码',
  `name` varchar(255) NOT NULL COMMENT '姓名',
  `role` enum('teacher','student') NOT NULL COMMENT '角色（教师或学生）',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';

CREATE TABLE `course` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '课程ID',
  `name` varchar(255) NOT NULL COMMENT '课程名称',
  `description` text NOT NULL COMMENT '课程描述',
  `cover` varchar(255) NOT NULL COMMENT '课程封面',
  `teacher_id` int(11) NOT NULL COMMENT '发布教师ID',
  FOREIGN KEY (`teacher_id`) REFERENCES `user` (`id`),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='课程表';

CREATE TABLE `homework` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '作业ID',
  `name` varchar(255) NOT NULL COMMENT '作业名称',
  `description` text NOT NULL COMMENT '作业描述',
  `deadline` datetime NOT NULL COMMENT '截止日期',
  `course_id` int(11) NOT NULL COMMENT '所属课程ID',
  FOREIGN KEY (`course_id`) REFERENCES `course` (`id`),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='作业表';

CREATE TABLE `homework_submission` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '提交ID',
  `student_id` int(11) NOT NULL COMMENT '提交学生ID',
  `homework_id` int(11) NOT NULL COMMENT '作业ID',
  `content` text NOT NULL COMMENT '作业内容',
  `file` varchar(255) DEFAULT NULL COMMENT '附件',
  `score` int(11) DEFAULT NULL COMMENT '评分',
  `comment` text DEFAULT NULL COMMENT '评语',
  FOREIGN KEY (`student_id`) REFERENCES `user` (`id`),
  FOREIGN KEY (`homework_id`) REFERENCES `homework` (`id`),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='作业提交表';

CREATE TABLE `announcement` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '公告ID',
  `title` varchar(255) NOT NULL COMMENT '公告标题',
  `content` text NOT NULL COMMENT '公告内容',
  `teacher_id` int(11) NOT NULL COMMENT '发布教师ID',
  FOREIGN KEY (`teacher_id`) REFERENCES `user` (`id`),
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='公告表';

/*
 Navicat Premium Data Transfer

 Source Server         : mysql5
 Source Server Type    : MySQL
 Source Server Version : 50717 (5.7.17-log)
 Source Host           : localhost:3306
 Source Schema         : online_edu_manager

 Target Server Type    : MySQL
 Target Server Version : 50717 (5.7.17-log)
 File Encoding         : 65001

 Date: 04/06/2023 11:55:25
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for announcement
-- ----------------------------
DROP TABLE IF EXISTS `announcement`;
CREATE TABLE `announcement`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '公共ID',
  `title` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '公告标题',
  `content` text CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '公告内容',
  `teacher_id` int(11) NOT NULL COMMENT '外键，关联user表',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `teacher_id`(`teacher_id`) USING BTREE,
  CONSTRAINT `announcement_ibfk_1` FOREIGN KEY (`teacher_id`) REFERENCES `user` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for course
-- ----------------------------
DROP TABLE IF EXISTS `course`;
CREATE TABLE `course`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '课程ID',
  `name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '课程名称',
  `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '课程描述',
  `cover` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '课程封面',
  `teacher_id` int(11) NOT NULL COMMENT '外键，关联user表',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `teacher_id`(`teacher_id`) USING BTREE,
  CONSTRAINT `course_ibfk_1` FOREIGN KEY (`teacher_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for homework
-- ----------------------------
DROP TABLE IF EXISTS `homework`;
CREATE TABLE `homework`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '作业ID',
  `name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '作业名称',
  `description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '作业描述',
  `deadline` datetime NULL DEFAULT NULL COMMENT '截止日期',
  `course_id` int(11) NULL DEFAULT NULL COMMENT '外键，关联course',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `course_id`(`course_id`) USING BTREE,
  CONSTRAINT `homework_ibfk_1` FOREIGN KEY (`course_id`) REFERENCES `course` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for homework_submission
-- ----------------------------
DROP TABLE IF EXISTS `homework_submission`;
CREATE TABLE `homework_submission`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '提交ID',
  `student_id` int(11) NOT NULL COMMENT '外键，关联user表',
  `homework_id` int(11) NOT NULL COMMENT '外键，关联homework表',
  `content` text CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '作业内容',
  `file` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '附件，可选',
  `score` int(11) NULL DEFAULT NULL COMMENT '评分',
  `comment` text CHARACTER SET utf8 COLLATE utf8_general_ci NULL COMMENT '评语',
  PRIMARY KEY (`id`) USING BTREE,
  INDEX `student_id`(`student_id`) USING BTREE,
  INDEX `homework_id`(`homework_id`) USING BTREE,
  CONSTRAINT `homework_submission_ibfk_1` FOREIGN KEY (`student_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  CONSTRAINT `homework_submission_ibfk_2` FOREIGN KEY (`homework_id`) REFERENCES `homework` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user`  (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `username` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '用户名',
  `password` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '密码',
  `name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '姓名',
  `role` enum('teacher','student') CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '角色（老师、学生）',
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE INDEX `username`(`username`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

online-teaching-management-system
  - static   #存放小程序上传的图片
  - utils
    - db.js
  - controllers
    - userController.js
    - courseController.js
    - homeworkController.js
    - announcementController.js
  - models
    - userModel.js
    - courseModel.js
    - homeworkModel.js
    - announcementModel.js
  - routes
    - userRoutes.js
    - courseRoutes.js
    - homeworkRoutes.js
    - announcementRoutes.js
  - app.js
  - uploadserver.js  #这是一个图片服务器，负责图片的上传和下载

npm init -y // 会帮助我们生成一个package.json
npm install express mysql body-parser cors multer uuid

// 图片上传服务器
const express = require("express")
const app = express()
const port = 9001 // 图片上传服务器的端口号

// 配置跨域
const cors = require("cors")
app.use(cors({
    origin: "*"
}))

// 配置multer文件上传中间件配置
const multer = require("multer")
// 使用uuid动态生成不重名的图片
const uuid = require("uuid")
// 配置上传参数
const uploadTools = multer({
    storage: multer.diskStorage({// 该存储方案将会把文件直接存入磁盘
        destination: (req, file, callback) => {// 处理存储
            callback(null, 'static')
        },
        filename: (req, file, callback) => {// 处理文件名，在这对文件名进行重新命名，防止文件名重复被替换
            // 通过file，获取原始文件名，比如：wanyin.jpeg
            let name = file.originalname
            console.log("--------文件名：", name)
            // 截取文件的扩展名，比如：.jpeg .png
            let ext = name.substr(name.lastIndexOf('.'))
            // 通过uuid生成一个16进制的随机文件名
            let newName = uuid.v4() + ext
            // 通过callback进行重新设置
            callback(null, newName)
        }
    })
})

//  配置static目录为静态资源托管文件夹，这样就可以直接通过：http://localhost:9001/文件名 访问static目录下的资源
app.use(express.static("static"))
//  配置上传请求
//  上传action: http://localhost:9001/upload
app.post('/upload', uploadTools.single('file'), (req, res) => {
    // 这是需要响应给前端的图片的地址，如果真机调试，这里的localhost换成你的电脑
    let url = "http://localhost:9001/" + req.file.filename
    console.log("图片上传成功！", url)
    res.status(200).json({code:1,msg:"图片上传成功！",url})
})

// 监听服务器启动状态
app.listen(port, () => {
    console.log("文件上传服务器启动成功！")
})

node uploadserver.js

// 这个就是后端服务器的入口文件
// 引入所需要的模块
const express = require("express") // 有了这个模块，我们就可以通过js做后端开发
const bodyParser = require("body-parser")// 有了这个模块，就可以自动实现对象和json字符出之间的转换
const mysql = require("mysql") // 有了这个代码模块，我们就可以使用js访问和操作数据库
// 创建后端服务
const app = express()

// 配置MySQL连接
const db = mysql.createConnection({
    host: "localhost",// 主机
    user: "root",// 数据库默认的账户
    password: "123456", // 数据库访问密码 
    database: "online_edu_manager", // 需要连接到的数据库名称
})
// 连接数据库
db.connect((err) => {
    if (err) {
        console.log("数据库连接失败！");
        throw err;
    }
    console.log("数据库连接成功！");
})
// 测试访问
app.get('/', (req, res) => {
    res.send('Hello World!');
});
// 配置body-parser中间件
app.use(bodyParser.urlencoded({ extended: false })) // 防止数据乱码
app.use(bodyParser.json()) // 对象转json

// 监听服务器是否启动
app.listen(3000, () => {
    console.log("服务器启动成功：http://localhost:3000");
})

node app.js

/**
 * MySQL数据库的配置与连接
 */

// 导入我们安装的mysql模块，这里需要注意，如果你的数据库是MySQL8.X，你需要安装mysql2
// 卸载：npm un mysql
// 安装：npm i mysql2
const mysql = require('mysql')

// 配置连接数据库的信息
const connection = mysql.createConnection({
    host:"localhost", // 这里是主机的地址，我们教学都是使用这个
    port:"3306",// 数据库的端口，有些同学装的数据库端口是3307，需要在这里配置，默认是3306
    user:"root",// 数据库默认的管理员账户
    password:"123456",// 数据库连接密码
    database:"online_edu_manager" // 数据库的名字
})

// 连接数据库
connection.connect(err=>{
    if(err){
        console.log("数据库连接失败");
        throw err
        // return
    }
    console.log("数据库连接成功");
})

// 公开，给其他文件调用
module.exports = connection

/**
 * 用户表（user）的操作
 */
const db = require("../utils/db.js")
/**
 * 注册，添加用户，包括老师和学生
 * @param {*} user：存放我们要添加到数据库的用户信息(username,password,name,role)
 * @param {*} callback：回调函数，操作数据库
 */
const addUser = (user,callback)=>{
    // 编写sql，这里需要使用?帮助我们占位
    const sql = "insert into user(username,password,name,role) values(?,?,?,?)"
    // 执行sql语句，同时使用我们传入的数据，替换到对应位置的?
    db.query(sql,[user.username,user.password,user.name,user.role],(err,result)=>{
        if(err){
            callback(err,null) // 失败
        }else{
            callback(null,result.insertId) // 成功
        }
    })
}

/**
 * 登录，查找用户，包括老师和学生
 * @param {*} user：user是一个对象，里面存放前端传入的username,password
 * @param {*} callback 
 */
const login = (user,callback)=>{
    // 编写sql
    const sql = "select id,username,name,role from user where username=? and password=?"
    // 执行sql
    db.query(sql,[user.username,user.password],(err,result)=>{
        if(err){
            callback(err,null) // 失败
        }else{
            callback(null,result[0]) // 我们只要一个信息
        }
    })
}

/**
 * 根据用户ID修改用户信息（除了密码），包括老师和学生
 * @param {*} user：user是一个对象，里面存放前端传入的username,name,id
 * @param {*} callback 
 */
const updateUser = (user,callback)=>{
    // 编写sql
    const sql = "update user set username=?,name=? where id=?"
    // 执行sql
    db.query(sql,[user.username,user.name,user.id],(err,result)=>{
        if(err){
            callback(err,null)// 失败
        }else{
            callback(null,result.affectedRows) // 成功
        }
    })
}

/**
 * 修改密码，根据账户设置新密码，包括老师和学生 {password:"xxx",id:xx}
 * @param {*} user 
 * @param {*} callback 
 */
const changePwd = (user,callback)=>{
    // 编写sql
    const sql = "update user set password=? where id=?"
    // 执行sql
    db.query(sql,[user.password,user.id],(err,result)=>{
        if(err){
            callback(err,null) // 失败
        }else{
            callback(null,result.affectedRows) // 成功
        }
    })
}

/**
 * 注销，根据用户ID删除信息，包括老师和学生
 * @param {*} userId 
 * @param {*} callback 
 */
const logout = (userId,callback)=>{
    // 编写sql
    const sql = "delete from user where id=?"
    // 执行sql
    db.query(sql,[userId],(err,result)=>{
        if(err){
            callback(err,null) // 失败
        }else{
            callback(null,result.affectedRows) // 成功
        }
    })
}

// 公开方法，给外部其他文件访问
module.exports = {
    addUser,
    login,
    updateUser,
    changePwd,
    logout
}

/**
 * 控制层，实现用户的业务逻辑
 */

const userModel = require("../models/userModels") // module.exports

// 用户注册
const register = (req, res) => {
    // 获取前端页面传递过来的信息
    const { username, password, name, role } = req.body;
    // 非空校验，可选
    if (!username) {
        res.status(200).json({ code: -1, msg:"用户名不能为空" })
    }
    if (!password) {
        res.status(200).json({ code: -1, msg:"密码不能为空" })
    }
    if (!name) {
        res.status(200).json({ code: -1, msg:"姓名不能为空" })
    }
    if (!role) {
        res.status(200).json({ code: -1, msg:"姓名不能为空" })
    }
    // 访问数据库
    userModel.addUser({ username, password, name, role }, (err, userId) => {
        if (err) {
            // res.status().json() 响应信息到前端
            res.status(500).json({code:-3,msg: "服务器错误" })
        } else {
            if (userId) {
                res.status(200).json({ code: 1, msg: "用户注册成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "用户注册失败！" })
            }
        }
    })
}

/**
 * 用户登录
 * @param {*} req：request的缩写，作用是获取到前端的请求信息
 * @param {*} res：response的缩写，作用是将后端数据响应给前端
 */
const login = (req, res) => {
    // 如果前端是通过表单提交的数据，后端获取使用：req.body
    const { username, password } = req.body
    // 非空校验
    if (!username) {
        res.status(200).json({ "code": -1, msg: "用户名不能为空" })
    }
    if (!password) {
        res.status(200).json({ "code": -1, msg: "用户密码不能为空" })
    }
    // 访问数据库
    userModel.login({ username, password }, (err, user) => {
        if (err) {
            console.error("用户登录：",err);
            res.status(500).json({code:-3,msg:"服务器错误"})
        }else{
            if(user){
                res.status(200).json({code:1,msg:"用户登录成功！",data:user})
            }else{
                res.status(200).json({code:0,msg:"用户登录失败！"})
            }
        }
    })
}

/**
 * 根据id修改用户信息
 * @param {*} req 
 * @param {*} res 
 */ 
const updateUser = (req,res)=>{
    // 获取前端传过来的表单信息
    const {id,username,name} = req.body
    // 非空校验
    if(!id){
        res.status(200).json({code:-1,msg:"用户id不能为空"})
    }
    if(!username){
        res.status(200).json({code:-1,msg:"用户登录名不能为空"})
    }
    if(!name){
        res.status(200).json({code:-1,msg:"用户姓名不能为空"})
    }
    // 访问数据库
    userModel.updateUser({id,username,name},(err,rows)=>{
        if(err){
            console.error("根据id修改用户信息：",err);
            res.status(500).json({code:-3,msg:"服务器错误"})
        }else{
            if(rows && rows>0){
                res.status(200).json({code:1,msg:"用户信息修改成功！"})
            }else{
                res.status(200).json({code:0,msg:"用户信息修改失败！"})
            }
        }
    })
}

/**
 * 修改密码
 * @param {*} req 
 * @param {*} res 
 */
const changePwd = (req,res)=>{
    // 获取前端传过来的表单信息
    const {id,password} = req.body 
    // 非空校验
    if(!id){
        res.status(200).json({code:-1,msg:"用户id不能为空"})
    }
    if(!password){
        res.status(200).json({code:-1,msg:"用户密码不能为空"})
    }
    // 访问数据库
    userModel.changePwd({id,password},(err,rows)=>{
        if(err){
            console.error("根据id修改用户密码：",err);
            res.status(500).json({code:-3,msg:"服务器错误"})
        }else{
            if(rows && rows>0){
                res.status(200).json({code:1,msg:"用户密码修改成功！"})
            }else{
                res.status(200).json({code:0,msg:"用户密码修改失败！"})
            }
        }
    })
}

/**
 * 注销
 * @param {*} req 
 * @param {*} res 
 */
const logout = (req,res)=>{
    // 获取地址栏携带的id：req.params
    const {id} = req.params 
    // 非空校验
    if(!id){
        res.status(200).json({code:-1,msg:"用户id不能为空"})
    }
    // 访问数据库
    userModel.logout(id,(err,rows)=>{
        if(err){
            console.error("注销用户：",err);
            res.status(200).json({code:-3,msg:"服务器错误"})
        }else{
            if(rows && rows >0){
                res.status(200).json({code:1,msg:"用户注销成功！"})
            }else{
                res.status(200).json({code:0,msg:"用户注销失败！"})
            }
        }
    })
}
module.exports = {
    register,
    login,
    updateUser,
    changePwd,
    logout
}

const express = require('express')
const router = express.Router()

// 导入controller
const userController = require("../controllers/userController")

/**
 * 用户注册接口
 * method：post
 * url：http://localhost:3000/user/register
 * params: {username:"",password:"",name:"",role:""}
 */
router.post('/register',userController.register)

/**
 * 用户登录接口
 * method：post
 * url：http://localhost:3000/user/login
 * params：{username:"",password:""}
 */
router.post('/login',userController.login)

/**
 * 用户信息修改接口
 * method：put
 * url：http://localhost:3000/user/update
 * params：{id:'',username:'',name:''}
 */
router.put("/update",userController.updateUser)

/**
 * 用户密码修改接口
 * method：put
 * url：http://localhost:3000/user/changePwd
 * params：{id:'',password:''}
 */
router.put("/changePwd",userController.changePwd)

/**
 * 用户注销接口
 * method：delete
 * url：http://localhost:3000/user/delete/1
 */
router.delete("/delete/:id",userController.logout) 

module.exports = router

// 这个就是后端服务器的入口文件
// 引入所需要的模块
const express = require("express") // 有了这个模块，我们就可以通过js做后端开发
const bodyParser = require("body-parser")// 有了这个模块，就可以自动实现对象和json字符出之间的转换
const cors = require("cors")

// 创建后端服务
const app = express()

// 导入路由
const userRoutes = require("./routes/userRoutes")

// 配置跨域
app.use(cors())

// 配置body-parser中间件
app.use(bodyParser.urlencoded({ extended: false })) // 防止数据乱码
app.use(bodyParser.json()) // 对象转json


// 注册路由
app.use("/user",userRoutes)  // http://localhost:3000/user/register


// 监听服务器是否启动
app.listen(3000, () => {
    console.log("服务器启动成功：http://localhost:3000");
})

/**
 * 课程表（course）的操作
 */
const db = require("../utils/db")


// 添加课程，跟老师有关
const addCourse = (course, callback) => {
    // 编写sql
    const sql = "insert into course(name,description,cover,teacher_id) values(?,?,?,?)"
    // 执行sql
    db.query(sql, [course.name, course.description, course.cover, course.teacher_id], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.insertId) // 成功
        }
    })
}

// 修改课程，跟老师有关
const updateCourse = (course, callback) => {
    // 编写sql
    const sql = "update course set name=?,description=?,cover=? where id=?"
    // 执行sql
    db.query(sql, [course.name, course.description, course.cover, course.id], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.affectedRows) // 成功
        }
    })
}

// 删除课程，跟老师有关
const deleteCourse = (courseId, callback) => {
    // 编写sql
    const sql = "delete from course where id=?"
    // 执行sql
    db.query(sql, [courseId], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.affectedRows) // 成功
        }
    })
}

// 根据老师ID查询课程
const findCoursesByTeacherId = (course, callback) => {
    // 编写sql
    const sql = "select * from course where teacher_id=? and name like ? limit ?,?"
    // 解构参数
    let { teacherId, keywords, startIndex, pageSize } = course
    // 执行sql
    db.query(sql, [teacherId, `%${keywords}%`, startIndex, pageSize], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results) // 成功
        }
    })
}

// 查询所有课程，给学生用
const findCourses = (course, callback) => {
    // 编写sql
    const sql = `select 
          c.id,
          c.name,
          c.description,
          c.cover,
          u.id as teacher_id,
          u.name as techer_name 
        from
          course c,
          user u 
        where c.teacher_id = u.id 
          and u.name like ? 
        limit ?, ? `
    // 解构参数
    const {keywords,startIndex,pageSize} = course // 关键字，开始索引，每页条数
    // 执行sql
    db.query(sql,[`%${keywords}%`,startIndex,pageSize],(err,results)=>{
        if(err){
            callback(err,null) // 失败
        }else{
            callback(null,results) // 成功
        }
    })
}

// 查询课程总数，预留
const countCourses = (course, callback) => {
   // 编写sql course{keywords,teacherId}
   
}

module.exports = {
    addCourse,
    updateCourse,
    deleteCourse,
    findCoursesByTeacherId,
    findCourses,
    countCourses
}

/**
 * 控制层，实现课程的业务逻辑
 */

const courseModel = require("../models/courseModels")

// 添加课程
const addCourse = (req, res) => {
    // 获取前端请求回来的数据
    const { name, description, cover, teacher_id } = req.body
    // 非空校验
    if (!name) {
        res.status(200).json({ code: -1, msg: "课程名称不能为空" })
    }
    if (!description) {
        res.status(200).json({ code: -1, msg: "课程描述不能为空" })
    }
    if (!cover) {
        res.status(200).json({ code: -1, msg: "课程封面不能为空" })
    }
    if (!teacher_id) {
        res.status(200).json({ code: -1, msg: "老师ID不能为空" })
    }
    // 访问数据库
    courseModel.addCourse({ name, description, cover, teacher_id }, (err, courseId) => {
        if (err) {
            console.log("添加课程：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (courseId) {
                res.status(200).json({ code: 1, msg: "课程添加成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "课程添加失败！" })
            }
        }
    })
}

// 修改课程
const updateCourse = (req, res) => {
    // 获取前端传递过来的请求数据
    const { name, description, cover, id } = req.body
    // 非空校验
    if (!name) {
        res.status(200).json({ code: -1, msg: "课程名称不能为空" })
    }
    if (!description) {
        res.status(200).json({ code: -1, msg: "课程描述不能为空" })
    }
    if (!cover) {
        res.status(200).json({ code: -1, msg: "课程封面不能为空" })
    }
    if (!id) {
        res.status(200).json({ code: -1, msg: "课程ID不能为空" })
    }
    // 访问数据库
    courseModel.updateCourse({ name, description, cover, id }, (err, rows) => {
        if (err) {
            console.log("修改课程：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (rows && rows > 0) {
                res.status(200).json({ code: 1, msg: "课程修改成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "课程修改失败！" })
            }
        }
    })
}

// 删除课程
const deleteCourse = (req, res) => {
    // 获取前端地址栏传递的课程ID
    const { id } = req.params
    // 非空校验
    if (!id) {
        res.status(200).json({ code: -1, msg: "课程ID不能为空" })
    }
    // 访问数据库
    courseModel.deleteCourse(id, (err, rows) => {
        if (err) {
            console.log("删除课程：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (rows && rows > 0) {
                res.status(200).json({ code: 1, msg: "课程删除成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "课程删除失败！" })
            }
        }
    })
}

// 根据老师id查询课程
const findCoursesById = (req, res) => {
    // 获取前端地址栏传递的老师ID,关键字，分页信息
    let { teacherId, keywords, startIndex, pageSize } = req.params
    // 处理关键字
    if (keywords == "''") {
        keywords = ""
    }
    // 访问数据库，转过来的数字字符串需要转换为数字
    courseModel.findCoursesByTeacherId({ teacherId:Number(teacherId), keywords, startIndex:Number(startIndex), pageSize:Number(pageSize) }, (err, results) => {
        if (err) {
            console.log("根据老师id查询课程：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (results && results.length > 0) {
                res.status(200).json({ code: 1, msg: "课程列表获取成功！", data: results })
            } else {
                res.status(200).json({ code: 0, msg: "课程列表获取失败！" })
            }
        }
    })
}

// 查询所有课程
const findCourses = (req, res) => {
    // 获取前端地址栏传递的老师ID,关键字，分页信息
    let { keywords, startIndex, pageSize } = req.params
    // 处理关键字
    if (keywords == "''") {
        keywords = ""
    }
    // 访问数据库
    courseModel.findCourses({ keywords, startIndex:Number(startIndex), pageSize:Number(pageSize) } , (err, results) => {
        if (err) {
            console.log("查询所有课程：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (results && results.length > 0) {
                res.status(200).json({ code: 1, msg: "课程列表获取成功！", data: results })
            } else {
                res.status(200).json({ code: 0, msg: "课程列表获取失败！" })
            }
        }
    })
}

module.exports = {
    addCourse,
    updateCourse,
    deleteCourse,
    findCoursesById,
    findCourses
}

const express = require('express')
const router = express.Router()

// 导入courseController
const courseController = require("../controllers/courseController")

/**
 * 添加课程接口
 * method：post
 * url：http://localhost:3000/course/addCourse
 * data：{name:"",description:"",cover:"",teacher_id:0}
 */
router.post("/addCourse", courseController.addCourse)

/**
 * 修改课程接口
 * method：put
 * url：http://localhost:3000/course/updateCourse
 * data：{name:"",description:"",cover:"",id:0}
 */
router.put("/updateCourse", courseController.updateCourse)

/**
 * 删除课程接口
 * method：delete
 * url：http://localhost:3000/course/deleteCourse/1
 */
router.delete("/deleteCourse/:id", courseController.deleteCourse)

/**
 * 根据老师id查询课程接口
 * method：get
 * url：http://localhost:3000/course/findCoursesById/1/''/0/5
 */
router.get("/findCoursesById/:teacherId/:keywords/:startIndex/:pageSize", courseController.findCoursesById)

/**
 * 查询所有课程接口
 * method：get
 * url：http://localhost:3000/course/findCourses/''/0/5
 */
router.get("/findCourses/:keywords/:startIndex/:pageSize",courseController.findCourses)

module.exports = router

// 这个就是后端服务器的入口文件
// 引入所需要的模块
const express = require("express") // 有了这个模块，我们就可以通过js做后端开发
const bodyParser = require("body-parser")// 有了这个模块，就可以自动实现对象和json字符出之间的转换
const cors = require("cors")

// 创建后端服务
const app = express()

// 导入路由
const userRoutes = require("./routes/userRoutes")
const courseRoutes = require("./routes/courseRoutes")
// 配置跨域
app.use(cors())

// 配置body-parser中间件
app.use(bodyParser.urlencoded({ extended: false })) // 防止数据乱码
app.use(bodyParser.json()) // 对象转json


// 注册路由
app.use("/user",userRoutes)  
app.use("/course",courseRoutes)

// 监听服务器是否启动
app.listen(3000, () => {
    console.log("服务器启动成功：http://localhost:3000");
})

/**
 * 作业表（homework）的操作
 */
const db = require("../utils/db")

// 老师添加作业
const addHomework = (homework, callback) => {
    // 编写sql
    const sql = "insert into homework(name,description,deadline,course_id) values(?,?,?,?)"
    // 执行sql
    db.query(sql, [homework.name, homework.description, homework.deadline, homework.course_id], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.insertId) // 成功
        }
    })
}

// 老师修改作业
const updateHomework = (homework, callback) => {
    // 编写sql
    const sql = "update homework set name=?,description=?,deadline=? where id=?"
    // 执行sql
    db.query(sql, [homework.name, homework.description, homework.deadline, homework.id], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.affectedRows) // 成功
        }
    })
}

// 老师删除作业
const deleteHomework = (homeworkId, callback) => {
    // 编写sql
    const sql = "delete from homework where id=?"
    // 执行sql
    db.query(sql, [homeworkId], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.affectedRows) // 成功
        }
    })
}

// 老师/学生查看作业
const findHomeworks = (homework, callback) => {
    console.log("homework:", homework);
    // 创建一个数组，存放参数
    let paramsArr = []
    // 编写sql
    let sql = `
            select 
              h.id,
              c.cover,
              h.name,
              h.description,
              h.deadline,
              c.name as course_name,
              u.name as teacher_name
            from
              user u,
              course c,
              homework h 
            where c.teacher_id = u.id 
              and h.course_id = c.id 
    `
    // 根据老师id查询某个老师的作业
    if (homework && homework.teacherId != -1) {
        sql += `
              and u.id = ?
        `
        paramsArr.push(homework.teacherId)
    }
    // 根据老师名称、课程名称、作业名称模糊查询作业
    sql += `
              and (
                  h.name like ? 
                  or c.name like ? 
                  or u.name like ?
              )
              limit ?,?
    `
    paramsArr.push(`%${homework.keywords}%`) // 作业名称
    paramsArr.push(`%${homework.keywords}%`) // 课程名称
    paramsArr.push(`%${homework.keywords}%`) // 老师名称
    paramsArr.push(homework.startIndex)// 开始索引
    paramsArr.push(homework.pageSize) // 每页显示条数
    console.log(sql, paramsArr);
    // 执行sql
    db.query(sql, paramsArr, (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results) // 成功
        }
    })
}

// 学生提交作业
const subHomework = (homework, callback) => {
    // 编写sql
    const sql = "insert into homework_submission(student_id,homework_id,content,file) values(?,?,?,?)"
    // 执行sql
    db.query(sql, [homework.studentId, homework.homeworkId, homework.content, homework.file], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.insertId) // 成功
        }
    })
}

// 老师查看学生提交的作业
const findSubHomeworks = (homework, callback) => {
    // 编写sql
    const sql = `
    SELECT
    	h.name as homework_name,
    	h.deadline,
    	c.name as course_name,
    	c.cover,
    	u.name as student_name,
    	hs.content,
    	hs.file
    FROM
        user u,
    	course c,
    	homework h,
    	homework_submission hs 
    WHERE
    	hs.homework_id = h.id and 
    	h.course_id = c.id and 
    	hs.student_id = u.id and 
    	c.teacher_id = ? and
        ISNULL(hs.score)
    	limit ?,?
    `
    // 执行sql
    db.query(sql, [homework.teacherId, homework.startIndex, homework.pageSize], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results) // 成功
        }
    })
}

// 老师批改作业
const correctingHomework = (homework, callback) => {
    // 编写sql
    const sql = "update homework_submission set score=?,comment=? where id=?"
    // 执行sql
    db.query(sql, [homework.score, homework.comment, homework.id], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results.affectedRows) // 成功
        }
    })
}

// 学生查看已批改的作业
const findCorrectedHomeworks = (homework,callback)=>{
    // 编写sql
    const sql = `
        SELECT
        	h.name as homework_name,
        	h.deadline,
        	c.name as course_name,
        	c.cover,
        	u.name as teacher_name,
        	hs.score,
        	hs.comment
        FROM
          user u,
        	course c,
        	homework h,
        	homework_submission hs 
        WHERE
        	hs.homework_id = h.id and 
        	h.course_id = c.id and 
        	c.teacher_id = u.id and 
        	hs.score is not null and 
        	hs.student_id = ?
        	limit ?,?
    `
    // 执行sql
    db.query(sql, [homework.studentId, homework.startIndex, homework.pageSize], (err, results) => {
        if (err) {
            callback(err, null) // 失败
        } else {
            callback(null, results) // 成功
        }
    })
}

module.exports = {
    addHomework,
    updateHomework,
    deleteHomework,
    findHomeworks,
    subHomework,
    findSubHomeworks,
    correctingHomework,
    findCorrectedHomeworks
}

/**
 * 控制层，实现作业的业务逻辑
 */
const homeworkModel = require("../models/homeworkModel")

// 老师布置作业
const addHomework = (req, res) => {
    // 获取前端表单提交的内容
    const { name, description, deadline, course_id } = req.body
    if (!name) {
        res.status(200).json({ code: -1, msg: "作业名称不能为空" })
    }
    if (!description) {
        res.status(200).json({ code: -1, msg: "作业描述不能为空" })
    }
    if (!deadline) {
        res.status(200).json({ code: -1, msg: "截至日期不能为空" })
    }
    if (!course_id) {
        res.status(200).json({ code: -1, msg: "课程ID不能为空" })
    }
    // 访问数据库
    homeworkModel.addHomework({ name, description, deadline, course_id }, (err, homeworkId) => {
        if (err) {
            console.log("布置作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (homeworkId) {
                res.status(200).json({ code: 1, msg: "作业布置成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "作业布置失败！" })
            }
        }
    })
}

// 老师修改作业
const updateHomework = (req, res) => {
    // 获取前端表单传递过来的请求数据
    const { name, description, deadline, id } = req.body
    if (!name) {
        res.status(200).json({ code: -1, msg: "作业名称不能为空" })
    }
    if (!description) {
        res.status(200).json({ code: -1, msg: "作业描述不能为空" })
    }
    if (!deadline) {
        res.status(200).json({ code: -1, msg: "截至日期不能为空" })
    }
    if (!id) {
        res.status(200).json({ code: -1, msg: "作业ID不能为空" })
    }
    // 访问数据库
    homeworkModel.updateHomework({ name, description, deadline, id }, (err, rows) => {
        if (err) {
            console.log("修改作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (rows && rows > 0) {
                res.status(200).json({ code: 1, msg: "作业修改成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "作业修改失败！" })
            }
        }
    })
}

// 老师删除作业
const deleteHomework = (req, res) => {
    // 获取路径上携带的作业id
    const { id } = req.params
    // 非空校验
    if (!id) {
        res.status(200).json({ code: -1, msg: "作业ID不能为空" })
    }
    // 访问数据库
    homeworkModel.deleteHomework(id, (err, rows) => {
        if (err) {
            console.log("删除作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (rows && rows > 0) {
                res.status(200).json({ code: 1, msg: "作业删除成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "作业删除失败！" })
            }
        }
    })
}

// 老师/学生查看作业
const findHomeworks = (req, res) => {
    console.log("-----", req.params);
    // 获取路径上携带的信息
    let { teacherId, keywords, startIndex, pageSize } = req.params
    // 处理老师编号
    if (teacherId == -1) {
        teacherId == null // 此时查所有课程
    }
    // 处理关键字
    if (keywords == "''") {
        keywords = ""
    }
    // 访问数据库
    homeworkModel.findHomeworks({ teacherId: Number(teacherId), keywords, startIndex: Number(startIndex), pageSize: Number(pageSize) }, (err, results) => {
        if (err) {
            console.log("查询所有作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (results && results.length > 0) {
                res.status(200).json({ code: 1, msg: "作业列表获取成功！", data: results })
            } else {
                res.status(200).json({ code: 0, msg: "作业列表获取失败！" })
            }
        }
    })
}

// 学生提交作业
const subHomework = (req, res) => {
    // 获取前端表单提交的数据
    const { studentId, homeworkId, content, file } = req.body
    // 非空判断
    if (!studentId) {
        res.status(200).json({ code: -1, msg: "学生ID不能为空" })
    }
    if (!homeworkId) {
        res.status(200).json({ code: -1, msg: "作业ID不能为空" })
    }
    if (!content) {
        res.status(200).json({ code: -1, msg: "作业内容不能为空" })
    }
    // 访问数据库
    homeworkModel.subHomework({ studentId, homeworkId, content, file }, (err, subHomeworkId) => {
        if (err) {
            console.log("提交作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (subHomeworkId) {
                res.status(200).json({ code: 1, msg: "作业提交成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "作业提交失败！" })
            }
        }
    })
}

// 老师查看已提交作业
const findSubHomeworks = (req, res) => {
    // 获取路径上携带的参数
    let { teacherId, startIndex, pageSize } = req.params
    // 访问数据库
    homeworkModel.findSubHomeworks({ teacherId: Number(teacherId), startIndex: Number(startIndex), pageSize: Number(pageSize) }, (err, results) => {
        if (err) {
            console.log("查询所有已提交作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (results && results.length > 0) {
                res.status(200).json({ code: 1, msg: "已提交作业列表获取成功！", data: results })
            } else {
                res.status(200).json({ code: 0, msg: "已提交作业列表获取失败！" })
            }
        } 
    })
}

// 老师批改作业
const correctingHomework = (req, res) => {
    // 获取前端表单传递过来的数据
    const { score, comment, id } = req.body
    // 非空校验
    if (!score) {
        res.status(200).json({ code: -1, msg: "评分不能为空" })
    }
    if (!comment) {
        res.status(200).json({ code: -1, msg: "评语不能为空" })
    }
    if (!id) {
        res.status(200).json({ code: -1, msg: "作业ID不能为空" })
    }
    // 访问数据库
    homeworkModel.correctingHomework({ score, comment, id }, (err, rows) => {
        if (err) {
            console.log("批改作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (rows && rows > 0) {
                res.status(200).json({ code: 1, msg: "作业批改成功！" })
            } else {
                res.status(200).json({ code: 0, msg: "作业批改失败！" })
            }
        }
    })
}

// 学生查看已批改的作业
const findCorrectedHomeworks = (req,res)=>{
    // 获取前端路径携带的数据
    let {studentId, startIndex, pageSize} = req.params
    // 访问数据库
    homeworkModel.findCorrectedHomeworks({studentId:Number(studentId), startIndex:Number(startIndex), pageSize:Number(pageSize)},(err,results)=>{
        if (err) {
            console.log("查询已批改的作业：", err);
            res.status(500).json({ code: -3, msg: "服务器错误" })
        } else {
            if (results && results.length > 0) {
                res.status(200).json({ code: 1, msg: "已批改作业列表获取成功！", data: results })
            } else {
                res.status(200).json({ code: 0, msg: "已批改作业列表获取失败！" })
            }
        }
    })
}
module.exports = {
    addHomework,
    updateHomework,
    deleteHomework,
    findHomeworks,
    subHomework,
    findSubHomeworks,
    correctingHomework,
    findCorrectedHomeworks
}