草庐IT

基于Vue+Nodejs实现宿舍管理系统

编程指南针 2023-09-16 原文 

​
作者主页：编程指南针

 简介：Java领域优质创作者、CSDN博客专家  Java项目、简历模板、学习资料、面试题库、技术互助

文末获取源码

​

项目编号：BS-QD-002

主要需求：

  • 学生信息录入、修改、删除、查询
  • 宿舍管理评分
  • 学生早起率、懒床率
  • 学生宿舍打扫频率
  • 学生晚归情况
  • 楼层管理

考虑到实用性，该系统需要拆分为两大子系统，一个是学生端系统，一个是后台管理端系统。学生端系统主要提供给学生使用，负责一些宿舍记录及个人信息记录的基本操作；后台管理模块则是主要负责对所有学生信息的整理，提供宿舍管理、楼层管理、数据查看等权限，提供给宿舍管理员使用的。

学生登陆

学生系统拥有以下功能：

  • 创建账户
  • 分配宿舍
  • 填写个人信息
  • 修改个人信息
  • 起床打卡（用于统计懒床率）
  • 归宿登记（用于统计晚归情况）
  • 打扫记录（用于统计宿舍打扫频率）
  • 查看宿日常数据

管理员登陆

管理系统拥有以下功能：

  • 楼层管理
  • 宿舍评价
  • 宿舍信息管理
  • 学生信息查看
  • 保洁人员管理
  • 统计学生早起率
  • 统计学生宿舍打扫频率
  • 统计学生晚归

超级管理员在享有上述管理员同等权限的同时额外拥有如下功能：

  • 创建管理员
  • 创建宿舍楼
  • 为宿舍楼分配管理员
  • 为宿舍楼分配保洁人员

前端：

  • Vue 作为基础框架
  • vue-router 控制路由（hash 模式）
  • vuex 状态管理
  • axios 接入数据
  • Vue-element-admin 作为基础框架

后台（Nodejs）：

  • Koa 作为基础框架
  • koa-router —— 服务端路由控制
  • koa-static —— 读取静态文件
  • koa-jwt —— JWT 登录校验
  • koa-body —— http body 数据处理
  • koa-compress —— Gzip 压缩
  • koa-cors —— CORS 解决跨域问题
  • sequelize —— ORM

数据库：

  • MySQL

数据库设计一览：

下面展示一下系统的部分功能：

仪表盘概揽：选择不同的宿舍楼查看相关信息

管理员管理：

宿舍楼管理

楼层管理

宿舍信息

宿舍入住学生信息

查看学生起床记录

查看学生归宿信息

查看学生宿舍打扫信息

查看个人信息

学生注册

注册后登陆系统

入住宿舍

起床打卡

归宿记录

打扫记录

后端工程：

前端工程

部门核心代码：

const { Building } = require("../model")

module.exports = {
  getStudents: async function(buildingId) {
    const FloorController = require("./floor_controller")
    let users = []
    const building = await Building.findOne({ where: { id: buildingId } })
    const floors = await building.getFloors()
    for (let floor of floors) {
      const floorId = floor.id
      users = [...users, ...(await FloorController.getStudents(floorId))]
    }
    return users
  },
  delBuilding: async function(id) {
    const { setStudentRoomNull } = require("./user_controller")
    const students = await this.getStudents(id)
    students.forEach(student => {
      setStudentRoomNull(student.id)
    })
    return await Building.destroy({ where: { id } })
  }
}


const _ = require("lodash")
const { User } = require("../model")

module.exports = {
  async getEvaluatesInfo(evaluates) {
    const cpEvaluates = _.cloneDeep(evaluates)
    for (let evaluate of cpEvaluates) {
      const creator = await evaluate.getUser()
      evaluate.dataValues.userName = creator.name
    }
    return cpEvaluates
  }
}

const { Floor } = require("../model")

module.exports = {
  getStudents: async function(floorId) {
    const { getStudentInfo } = require("./user_controller")
    let users = []
    const floor = await Floor.findOne({ where: { id: floorId } })
    const rooms = await floor.getRooms()
    for (let room of rooms) {
      const roomUsers = await room.getUsers()
      for (let user of roomUsers) {
        users.push(await getStudentInfo(user.id))
      }
    }
    return users
  }
}


module.exports = {
  UserController: require("./user_controller"),
  RoomController: require("./room_controller"),
  FloorController: require("./floor_controller"),
  BuildingController: require("./building_controller"),
  EvaluateController: require("./evaluate_controller"),
  RecordController: require("./record_controller")
}


const {
  User,
  GetupRecord,
  CleanRecord,
  BackRecord,
  Room,
  Floor,
  Building
} = require("../model")
const { Op } = require("sequelize")
const moment = require("moment")
const _ = require("lodash")

const getupEarlyPoint = 8
const backEarlyPoint = 22

module.exports = {
  // getup 相关
  async addGetupRecord(userId) {
    const user = await User.findOne({ where: { id: userId } })
    const todyRecord = await GetupRecord.findOne({
      where: {
        userId: user.id,
        roomId: user.roomId,
        createdAt: {
          [Op.gt]: moment()
            .startOf("day")
            .toDate(),
          [Op.lt]: moment()
            .endOf("day")
            .toDate()
        }
      }
    })
    if (todyRecord) {
      throw new Error("当天已经有记录，记录失败!")
    }
    return await GetupRecord.create({ userId: user.id, roomId: user.roomId })
  },
  async getUserGetupRecords(userId, days, pure = false) {
    days = parseInt(days)
    const user = await User.findOne({ where: { id: userId } })
    const roomId = user.roomId
    const room = await Room.findOne({ where: { id: roomId } })
    // 获取最近 days 天的记录
    const startTime = moment()
      .subtract(days - 1 /* -1 代表查询天数包括今天 */, "days")
      .startOf("day")
      .toDate()
    const allRecords = []
    for (let i = 0; i < days; i++) {
      const todayStart = moment(startTime)
        .add(i, "days")
        .toDate()
      const todayEnd = moment(todayStart)
        .endOf("day")
        .toDate()
      let record = await GetupRecord.findOne({
        where: {
          userId,
          roomId,
          createdAt: {
            [Op.gt]: todayStart,
            [Op.lt]: todayEnd
          }
        },
        attributes: { exclude: ["updatedAt", "deletedAt"] }
      })
      if (record) {
        // 如果当天有记录就推入结果
        record = record.toJSON()
        record.time = moment(record.createdAt).format("HH:mm")
      } else if (!record && !pure) {
        // 如果获取的是全部数据且当前天无数据
        // 就建立一条空记录
        record = GetupRecord.build({
          id: "fake" + i,
          roomId,
          userId,
          createdAt: todayStart
        }).toJSON()
        record.time = null
      } else {
        continue
      }
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      record.userName = user.name
      record.roomNumber = room.number
      allRecords.push(record)
    }
    return allRecords.reverse()
  },
  async getRoomGetupRecords(roomId, days, pure = false) {
    days = parseInt(days)
    const room = await Room.findOne({ where: { id: roomId } })
    const users = await room.getUsers()
    const records = {}
    for (let user of users) {
      records[user.name] = await this.getUserGetupRecords(user.id, days, pure)
    }
    return records
  },
  async getGetupRecordLineCharData(roomId) {
    const room = await Room.findOne({ where: { id: roomId } })
    const users = await room.getUsers()
    const data = { columns: ["周期"], rows: [] }
    const dataCount = 5 // 获取的记录条数
    const dataStep = 7 // 每条记录相隔的条数
    // 初始化记录值
    for (let i = 0; i < dataCount; i++) {
      data.rows.push({ 周期: `最近${(i + 1) * dataStep}天` })
    }
    // 遍历当前宿舍的用户
    for (let user of users) {
      data.columns.push(user.name)
      for (let i = 0; i < dataCount; i++) {
        const days = (i + 1) * dataStep
        // 获取某学生最近 days 天的早起记录
        const records = await this.getUserGetupRecords(user.id, days, true)
        let earlyTimes = 0
        records.forEach(record => {
          // 统计这些记录中有几天是早起的
          const timeHour = parseInt(moment(record.createdAt).format("HH"))
          if (timeHour < getupEarlyPoint) {
            earlyTimes++
          }
        })
        // 计算早起率
        const probability = (earlyTimes / days).toFixed(4)
        data.rows[i][user.name] = probability
      }
    }
    return data
  },
  async getGetupTableData({
    current,
    step,
    buildingId,
    floorId,
    roomId,
    userId,
    startTime,
    endTime
  }) {
    // 初始化时间
    startTime = startTime
      ? moment(startTime)
          .startOf("day")
          .toDate()
      : moment(0).toDate()
    endTime = endTime
      ? moment(endTime)
          .endOf("day")
          .toDate()
      : moment()
          .endOf("day")
          .toDate()
    console.log("endTime: ", endTime)
    // 开始分情况获取数据
    let result
    if (userId) {
      result = await GetupRecord.findAndCountAll({
        where: {
          userId: userId,
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (roomId) {
      result = await GetupRecord.findAndCountAll({
        where: {
          roomId: roomId,
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (floorId) {
      result = await GetupRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        include: [
          {
            model: Room,
            where: { floorId }
          }
        ],
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (buildingId) {
      result = await GetupRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        include: [
          {
            model: Room,
            where: { buildingId }
          }
        ],
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else {
      result = await GetupRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    }
    const getStudentInfo = require("./user_controller").getStudentInfo
    let rows = []
    for (let record of result.rows) {
      record = record.toJSON()
      delete record.room
      const userInfo = await getStudentInfo(record.userId)
      record = Object.assign(userInfo, record)
      record.time = moment(record.createdAt).format("HH:mm")
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      if (parseInt(moment(record.createdAt).format("HH")) < getupEarlyPoint) {
        record.early = true
      } else {
        record.early = false
      }
      rows.push(record)
    }
    result.rows = rows
    return result
  },

  // back 相关
  async addBackRecord(userId) {
    const user = await User.findOne({ where: { id: userId } })
    const todyRecord = await BackRecord.findOne({
      where: {
        userId: user.id,
        roomId: user.roomId,
        createdAt: {
          [Op.gt]: moment()
            .startOf("day")
            .toDate(),
          [Op.lt]: moment()
            .endOf("day")
            .toDate()
        }
      }
    })
    if (todyRecord) {
      throw new Error("当天已经有记录，记录失败!")
    }
    return await BackRecord.create({ userId: user.id, roomId: user.roomId })
  },
  async getUserBackRecords(userId, days, pure = false) {
    days = parseInt(days)
    const user = await User.findOne({ where: { id: userId } })
    const roomId = user.roomId
    const room = await Room.findOne({ where: { id: roomId } })
    // 获取最近 days 天的记录
    const startTime = moment()
      .subtract(days - 1 /* -1 代表查询天数包括今天 */, "days")
      .startOf("day")
      .toDate()
    const allRecords = []
    for (let i = 0; i < days; i++) {
      const todayStart = moment(startTime)
        .add(i, "days")
        .toDate()
      const todayEnd = moment(todayStart)
        .endOf("day")
        .toDate()
      let record = await BackRecord.findOne({
        where: {
          userId,
          roomId,
          createdAt: {
            [Op.gt]: todayStart,
            [Op.lt]: todayEnd
          }
        },
        attributes: { exclude: ["updatedAt", "deletedAt"] }
      })
      if (record) {
        // 如果当天有记录就推入结果
        record = record.toJSON()
        record.time = moment(record.createdAt).format("HH:mm")
      } else if (!record && !pure) {
        // 如果获取的是全部数据且当前天无数据
        // 就建立一条空记录
        record = BackRecord.build({
          id: "fake" + i,
          roomId,
          userId,
          createdAt: todayStart
        }).toJSON()
        record.time = null
      } else {
        continue
      }
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      record.userName = user.name
      record.roomNumber = room.number
      allRecords.push(record)
    }
    return allRecords.reverse()
  },
  async getRoomBackRecords(roomId, days, pure = false) {
    days = parseInt(days)
    const room = await Room.findOne({ where: { id: roomId } })
    const users = await room.getUsers()
    const records = {}
    for (let user of users) {
      records[user.name] = await this.getUserBackRecords(user.id, days, pure)
    }
    return records
  },
  async getBackRecordLineCharData(roomId) {
    const room = await Room.findOne({ where: { id: roomId } })
    const users = await room.getUsers()
    const data = { columns: ["周期"], rows: [] }
    const dataCount = 5 // 获取的记录条数
    const dataStep = 7 // 每条记录相隔的条数
    // 初始化记录值
    for (let i = 0; i < dataCount; i++) {
      data.rows.push({ 周期: `最近${(i + 1) * dataStep}天` })
    }
    // 遍历当前宿舍的用户
    for (let user of users) {
      data.columns.push(user.name)
      for (let i = 0; i < dataCount; i++) {
        const days = (i + 1) * dataStep
        // 获取某学生最近 days 天的归宿记录
        const records = await this.getUserBackRecords(user.id, days, true)
        let earlyTimes = 0
        records.forEach(record => {
          // 统计这些记录中有几天是早归的
          const timeHour = parseInt(moment(record.createdAt).format("HH"))
          if (timeHour < backEarlyPoint) {
            earlyTimes++
          }
        })
        // 计算早起率
        const probability = (earlyTimes / days).toFixed(4)
        data.rows[i][user.name] = probability
      }
    }
    return data
  },
  async getBackTableData({
    current,
    step,
    buildingId,
    floorId,
    roomId,
    userId,
    startTime,
    endTime
  }) {
    // 初始化时间
    startTime = startTime
      ? moment(startTime)
          .startOf("day")
          .toDate()
      : moment(0).toDate()
    endTime = endTime
      ? moment(endTime)
          .endOf("day")
          .toDate()
      : moment()
          .endOf("day")
          .toDate()
    // 开始分情况获取数据
    let result
    if (userId) {
      result = await BackRecord.findAndCountAll({
        where: {
          userId: userId,
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (roomId) {
      result = await BackRecord.findAndCountAll({
        where: {
          roomId: roomId,
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (floorId) {
      result = await BackRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        include: [
          {
            model: Room,
            where: { floorId }
          }
        ],
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (buildingId) {
      result = await BackRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        include: [
          {
            model: Room,
            where: { buildingId }
          }
        ],
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else {
      result = await BackRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    }
    const getStudentInfo = require("./user_controller").getStudentInfo
    let rows = []
    for (let record of result.rows) {
      record = record.toJSON()
      delete record.room
      const userInfo = await getStudentInfo(record.userId)
      record = Object.assign(userInfo, record)
      record.time = moment(record.createdAt).format("HH:mm")
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      if (parseInt(moment(record.createdAt).format("HH")) < backEarlyPoint) {
        record.early = true
      } else {
        record.early = false
      }
      rows.push(record)
    }
    result.rows = rows
    return result
  },

  // clean 相关
  async addCleanRecord(userId) {
    const user = await User.findOne({ where: { id: userId } })
    const todyRecord = await CleanRecord.findOne({
      where: {
        roomId: user.roomId,
        createdAt: {
          [Op.gt]: moment()
            .startOf("day")
            .toDate(),
          [Op.lt]: moment()
            .endOf("day")
            .toDate()
        }
      }
    })
    if (todyRecord) {
      throw new Error("当天已经有清扫记录，记录失败")
    }
    return await CleanRecord.create({
      userId: user.id,
      roomId: user.roomId
    })
  },
  async getUserCleanRecords(userId, days) {
    // 获取打扫记录不会自动补全每一天的信息
    days = parseInt(days)
    const user = await User.findOne({ where: { id: userId } })
    const roomId = user.roomId
    const room = await Room.findOne({ where: { id: roomId } })
    // 获取最近 days 天的记录
    const startTime = moment()
      .subtract(days - 1 /* -1 代表查询天数包括今天 */, "days")
      .startOf("day")
      .toDate()
    const todayEnd = moment()
      .endOf("day")
      .toDate()
    const records = await CleanRecord.findAll({
      where: {
        userId,
        roomId,
        createdAt: {
          [Op.gt]: startTime,
          [Op.lt]: todayEnd
        }
      },
      attributes: { exclude: ["updatedAt", "deletedAt"] },
      order: [["createdAt", "DESC"]]
    })
    const allRecords = []
    records.forEach(record => {
      record = record.toJSON()
      record.time = moment(record.createdAt).format("HH:mm")
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      record.userName = user.name
      record.roomNumber = room.number
      allRecords.push(record)
    })
    return allRecords
  },
  async getRoomCleanRecords(roomId, days) {
    const room = await Room.findOne({ where: { id: roomId } })
    const startTime = moment()
      .subtract(days - 1 /* -1 代表查询天数包括今天 */, "days")
      .startOf("day")
      .toDate()
    const todayEnd = moment()
      .endOf("day")
      .toDate()
    const records = await room.getCleanRecords({
      where: {
        createdAt: {
          [Op.gt]: startTime,
          [Op.lt]: todayEnd
        }
      },
      attributes: { exclude: ["updatedAt", "deletedAt"] },
      order: [["createdAt", "DESC"]]
    })
    const allRecords = []
    for (let record of records) {
      const user = await record.getUser()
      record = record.toJSON()
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      record.time = moment(record.createdAt).format("HH:mm")
      record.userName = user.name
      record.roomNumber = room.number
      allRecords.push(record)
    }
    return allRecords
  },
  async getCleanTableData({
    current,
    step,
    buildingId,
    floorId,
    roomId,
    userId,
    startTime,
    endTime
  }) {
    // 初始化时间
    startTime = startTime
      ? moment(startTime)
          .startOf("day")
          .toDate()
      : moment(0).toDate()
    endTime = endTime
      ? moment(endTime)
          .endOf("day")
          .toDate()
      : moment()
          .endOf("day")
          .toDate()
    // 开始分情况获取数据
    let result
    if (userId) {
      result = await CleanRecord.findAndCountAll({
        where: {
          userId: userId,
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (roomId) {
      result = await CleanRecord.findAndCountAll({
        where: {
          roomId: roomId,
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (floorId) {
      result = await CleanRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        include: [
          {
            model: Room,
            where: { floorId }
          }
        ],
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else if (buildingId) {
      result = await CleanRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        include: [
          {
            model: Room,
            where: { buildingId }
          }
        ],
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    } else {
      result = await CleanRecord.findAndCountAll({
        where: {
          createdAt: {
            [Op.gt]: startTime,
            [Op.lt]: endTime
          }
        },
        limit: step,
        offset: step * (current - 1),
        order: [["createdAt", "DESC"]]
      })
    }
    const getStudentInfo = require("./user_controller").getStudentInfo
    let rows = []
    for (let record of result.rows) {
      record = record.toJSON()
      delete record.room
      const userInfo = await getStudentInfo(record.userId)
      record = Object.assign(userInfo, record)
      record.time = moment(record.createdAt).format("HH:mm")
      record.date = moment(record.createdAt).format("YYYY-MM-DD")
      record.early = null
      rows.push(record)
    }
    result.rows = rows
    return result
  },

  // 通用
  async getUserProbability(type, userId) {
    const user = await User.findById(userId)
    const startTime = user.checkTime
    let records = []
    let allRecords = []
    switch (type) {
      case "getup":
        allRecords = await user.getGetupRecords({
          where: {
            createdAt: { [Op.gt]: startTime }
          }
        })
        allRecords.forEach(record => {
          let hour = parseInt(moment(record.createdAt).format("HH"))
          if (hour < getupEarlyPoint) {
            records.push(record)
          }
        })
        break
      case "back":
        allRecords = await user.getBackRecords({
          where: {
            createdAt: { [Op.gt]: startTime }
          }
        })
        allRecords.forEach(record => {
          let hour = parseInt(moment(record.createdAt).format("HH"))
          if (hour < backEarlyPoint) {
            records.push(record)
          }
        })
        break
      case "clean":
        records = await user.getCleanRecords({
          where: {
            createdAt: { [Op.gt]: startTime }
          }
        })
        break
      default:
        throw new Error("参数传入错误")
    }
    // 计算从入住到现在有几天了
    const days = Math.abs(moment(startTime).diff(moment(), "days"))
    return (records.length / (days + 1)).toFixed(4)
  }
}


const { User } = require("../model")
const _ = require("lodash")
const RecordController = require("./record_controller")

module.exports = {
  /**
   * 获取学生用户的完整信息
   * @param {Number} userId
   */
  async getStudentInfo(userId) {
    const student = await User.findOne({
      where: { id: userId },
      attributes: { exclude: ["password", "deletedAt"] }
    })
    const room = await student.getRoom()
    const floor = await room.getFloor()
    const building = await floor.getBuilding()
    const getupProb = await RecordController.getUserProbability("getup", userId)
    const backProb = await RecordController.getUserProbability("back", userId)
    const cleanProb = await RecordController.getUserProbability("clean", userId)
    const info = Object.assign(student.dataValues, {
      roomNumber: room.number,
      floorId: floor.id,
      floorLayer: floor.layer,
      buildingId: building.id,
      buildingName: building.name,
      getupProb,
      backProb,
      cleanProb
    })
    return info
  },

  /**
   * 获取学生用户们的完整信息
   * @param {Array} users
   */
  async getStudentsInfo(users) {
    const cloneUsers = _.cloneDeep(users)
    for (let user of cloneUsers) {
      delete user.dataValues.password
      delete user.dataValues.deletedAt
      const room = await user.getRoom()
      const floor = await room.getFloor()
      const building = await floor.getBuilding()
      Object.assign(user.dataValues, {
        roomNumber: room.number,
        floorId: floor.id,
        floorLayer: floor.layer,
        buildingId: building.id,
        buildingName: building.name
      })
    }
    return cloneUsers
  },

  async setStudentRoomNull(id) {
    const student = await User.findOne({ where: { id, role: "student" } })
    const result = await student.update({ roomId: null })
    return result
  }
}

宿舍Nodejsstylerecord34vue.js前端毕业设计vue+nodejs毕业设计宿舍管理系统前端宿舍管理

有关基于Vue+Nodejs实现宿舍管理系统的更多相关文章

  1. ruby - i18n Assets 管理/翻译 UI - 2

    我正在使用i18n从头开始​​构建一个多语言网络应用程序，虽然我自己可以处理一大堆yml文件，但我说的语言(非常)有限，最终我想寻求外部帮助帮助。我想知道这里是否有人在使用UI插件/gem(与django上的django-rosetta不同)来处理多个翻译器，其中一些翻译器不愿意或无法处理存储库中的100多个文件，处理语言数据。谢谢&问候，安德拉斯(如果您已经在ruby​​onrails-talk上遇到了这个问题，我们深表歉意) 最佳答案 有一个rails3branchofthetolkgem在github上。您可以通过在Gemfi

  2. ruby - 如何根据特征实现 FactoryGirl 的条件行为 - 2

    我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden

  3. ruby-on-rails - 获取 inf-ruby 以使用 ruby​​ 版本管理器 (rvm) - 2

    我安装了ruby​​版本管理器，并将RVM安装的ruby​​实现设置为默认值，这样'哪个ruby'显示'~/.rvm/ruby-1.8.6-p383/bin/ruby'但是当我在emacs中打开inf-ruby缓冲区时，它使用安装在/usr/bin中的ruby​​。有没有办法让emacs像shell一样尊重ruby​​的路径？谢谢! 最佳答案 我创建了一个emacs扩展来将rvm集成到emacs中。如果您有兴趣，可以在这里获取:http://github.com/senny/rvm.el

  4. ruby-on-rails - 事件管理员日期过滤器日期格式自定义 - 2

    是否有简单的方法来更改默认ISO格式(yyyy-mm-dd)的ActiveAdmin日期过滤器显示格式？ 最佳答案 您可以像这样为日期选择器提供额外的选项，而不是覆盖js:=f.input:my_date,as::datepicker,datepicker_options:{dateFormat:"mm/dd/yy"} 关于ruby-on-rails-事件管理员日期过滤器日期格式自定义，我们在StackOverflow上找到一个类似的问题： https://s

  5. 叮咚买菜基于 Apache Doris 统一 OLAP 引擎的应用实践 - 2

    导读：随着叮咚买菜业务的发展，不同的业务场景对数据分析提出了不同的需求，他们希望引入一款实时OLAP数据库，构建一个灵活的多维实时查询和分析的平台，统一数据的接入和查询方案，解决各业务线对数据高效实时查询和精细化运营的需求。经过调研选型，最终引入ApacheDoris作为最终的OLAP分析引擎，Doris作为核心的OLAP引擎支持复杂地分析操作、提供多维的数据视图，在叮咚买菜数十个业务场景中广泛应用。作者｜叮咚买菜资深数据工程师韩青叮咚买菜创立于2017年5月，是一家专注美好食物的创业公司。叮咚买菜专注吃的事业，为满足更多人“想吃什么”而努力，通过美好食材的供应、美好滋味的开发以及美食品牌的孵

  6. 电脑0x0000001A蓝屏错误怎么U盘重装系统教学 - 2

    　　电脑0x0000001A蓝屏错误怎么U盘重装系统教学分享。有用户电脑开机之后遇到了系统蓝屏的情况。系统蓝屏问题很多时候都是系统bug，只有通过重装系统来进行解决。那么蓝屏问题如何通过U盘重装新系统来解决呢？来看看以下的详细操作方法教学吧。　　准备工作：　　1、U盘一个（尽量使用8G以上的U盘）。　　2、一台正常联网可使用的电脑。　　3、ghost或ISO系统镜像文件（Win10系统下载_Win10专业版_windows10正式版下载-系统之家）。　　4、在本页面下载U盘启动盘制作工具：系统之家U盘启动工具。　　U盘启动盘制作步骤：　　注意：制作期间，U盘会被格式化，因此U盘中的重要文件请注

  7. 华为OD机试用Python实现 -【明明的随机数】 2023Q1A - 2

    华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o

  8. 【鸿蒙应用开发系列】- 获取系统设备信息以及版本API兼容调用方式 - 2

    在应用开发中，有时候我们需要获取系统的设备信息，用于数据上报和行为分析。那在鸿蒙系统中，我们应该怎么去获取设备的系统信息呢，比如说获取手机的系统版本号、手机的制造商、手机型号等数据。1、获取方式这里分为两种情况，一种是设备信息的获取，一种是系统信息的获取。1.1、获取设备信息获取设备信息，鸿蒙的SDK包为我们提供了DeviceInfo类，通过该类的一些静态方法，可以获取设备信息，DeviceInfo类的包路径为：ohos.system.DeviceInfo.具体的方法如下：ModifierandTypeMethodDescriptionstatic StringgetAbiList​()Obt

  9. 基于C#实现简易绘图工具【100010177】 - 2

    C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.

  10. MIMO-OFDM无线通信技术及MATLAB实现（1）无线信道：传播和衰落 - 2

     MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO

随机推荐