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

前端工程

部门核心代码：

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: {

.startOf(“day”)

.toDate(),

.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: {

}

},

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: {

}

},

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else if (roomId) {

result = await GetupRecord.findAndCountAll({

where: {

roomId: roomId,

createdAt: {

}

},

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else if (floorId) {

result = await GetupRecord.findAndCountAll({

where: {

createdAt: {

}

},

include: [

{

model: Room,

where: { floorId }

}

],

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else if (buildingId) {

result = await GetupRecord.findAndCountAll({

where: {

createdAt: {

}

},

include: [

{

model: Room,

where: { buildingId }

}

],

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else {

result = await GetupRecord.findAndCountAll({

where: {

createdAt: {

}

},

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: {

.startOf(“day”)

.toDate(),

.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: {

}

},

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: {

}

},

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else if (roomId) {

result = await BackRecord.findAndCountAll({

where: {

roomId: roomId,

createdAt: {

}

},

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else if (floorId) {

result = await BackRecord.findAndCountAll({

where: {

createdAt: {

}

},

include: [

{

model: Room,

where: { floorId }

}

],

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else if (buildingId) {

result = await BackRecord.findAndCountAll({

where: {

createdAt: {

}

},

include: [

{

model: Room,

where: { buildingId }

}

],

limit: step,

offset: step * (current - 1),

order: [[“createdAt”, “DESC”]]

})

} else {

result = await BackRecord.findAndCountAll({

where: {

createdAt: {

}

},

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: {

.startOf(“day”)

.toDate(),

.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: {

}

},

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: {

}

},

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

}) {

// 初始化时间

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后

基础知识是前端一面必问的，如果你在基础知识这一块翻车了，就算你框架玩的再6，webpack、git、node学习的再好也无济于事，因为对方就不会再给你展示的机会，千万不要因为基础错过了自己心怡的公司。前端的基础知识杂且多，并不是理解就ok了，有些是真的要去记。当然了我们是牛x的前端工程师，每天像背英语单词一样去背知识点就没必要了，只要平时工作中多注意总结，面试前端刷下题目就可以了。

什么？你问面试题资料在哪里，这不是就在你眼前吗（滑稽

]]

})

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

}) {

// 初始化时间

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

[外链图片转存中…(img-NLJOeonr-1712671616838)]

[外链图片转存中…(img-9WDwIqnF-1712671616838)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

[外链图片转存中…(img-sLnhovtx-1712671616839)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：前端）

最后

基础知识是前端一面必问的，如果你在基础知识这一块翻车了，就算你框架玩的再6，webpack、git、node学习的再好也无济于事，因为对方就不会再给你展示的机会，千万不要因为基础错过了自己心怡的公司。前端的基础知识杂且多，并不是理解就ok了，有些是真的要去记。当然了我们是牛x的前端工程师，每天像背英语单词一样去背知识点就没必要了，只要平时工作中多注意总结，面试前端刷下题目就可以了。

什么？你问面试题资料在哪里，这不是就在你眼前吗（滑稽

资料领取方式：戳这里获取