AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

基于Nodejs+vue开发实现酒店管理系统

2023-12-22 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 基于Nodejs+vue开发实现酒店管理系统

项目编号：BS-QD-KS-002

一，项目简介

本项目使用纯前端技术开发实现一个酒店管理系统，前端采用VUE开发实现，后台通过NODEJS作为服务器开发实现，主要实现了酒店管理系统中的：房型管理、房间管理、顾客管理、订单管理等，用户可以注册并登陆后进行相应的管理操作。主要说明

  1. 前后端分离技术
  2. 前端使用vuejs,ElementUI,axios前后端通信，图标使用了ElementUI自带的图标还有font-awesome.css的图标库， 阿里的iconfont图标库也不错，这里没用。
  3. 后端使用了nodejs，nodejs采用了Express框架,orm采用的是Sequelize操作数据库（效率极高）,restful风格的Api, 跨域是由后端解决的，采用的是nodejs的cors模块（比较方便）。
  4. 数据库采用了mysql5.2（建议大家换成最新的mysql版本）
  5. 使用jsonwebtoken验证用户调用api的权限,增加接口的安全性，防止恶意攻击接口，串改数据。
  6. 主要界面里面的图片主要使用的是网上的图片，免费而且美观。

二，环境介绍

语言环境：nodejs

数据库： mysql5.7

应用服务器：nodejs

开发工具：IDEA或vscode

开发技术：nodejs+vue+elementUI

三，系统展示

用户注册

用户登陆

房间管理

房型管理

订单管理

订单管理

四，核心代码展示

const { Op } = require('sequelize')//nodejs的sequelize模块
const express = require('express')//express框架
const admin = require('../crud/table/admin.js')//引入管理员信息表
const token = require('../comment/token.js')//引入token模块
const adminRouter = express.Router()//express路由
adminRouter.post('/register',(req,res) =>{//管理员注册
    const { adminId, adminName, adminPassword } = req.body;
    admin.findOne({
        where:{
            adminId:adminId
        }
    })
    .then(data =>{
        if(data){
            res.status(200).json({
                msg:'该用户已经注册',
                success:false
            })
            return new Promise(() =>{})
        }else{
            return admin.create({
                adminId, adminName, adminPassword
            })
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'管理员注册成功！',
            admin:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'内部服务器错误！'
        })
    })
})
adminRouter.get('/login',(req,res) =>{//登录
    const { adminId, adminPassword } = req.query;
    let adminInfo;
    admin.findOne({
        where:{
            adminId
        }
    })
    .then(data =>{
        if(data){
            if(data.get().adminPassword==adminPassword){
                adminInfo = data.get();
                return token.setToken(data.get())
            }else{
                res.status(200).json({
                    success:false,
                    msg:'用户密码错误！'
                });  
                return new Promise(() =>{})
            }
        }else{
           res.status(200).json({
               success:false,
               msg:'该用户还未注册！'
           })
           return new Promise(() =>{})
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            admin:adminInfo,
            token:data,
            msg:'登录成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'内部服务器出错！'
        })
    })
})
adminRouter.put('/update',(req,res) =>{//修改管理员信息
    const { adminId, adminName, adminPassword, adminSex, adminAge } = req.body;
    admin.findOne({
        where:{
            adminId,adminPassword
        }
    })
    .then(data =>{
        if(data){
           return admin.update({
                    adminName,adminSex,adminAge
                },{
                    where:{
                        adminId,adminPassword
                    }
                })
        }else{
            res.status(200).json({
                success:false,
                msg:'管理员账号或者密码错误！'
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        return admin.findOne({
            where:{
                adminId,adminPassword
            }
        })
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'管理员信息修改成功！',
            admin:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误!'
        })
    })
})
adminRouter.delete('/del',(req,res) =>{
    const { adminId } = req.body || req.query;
    admin.destroy({
        where:{
            adminId
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'删除成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'删除失败!'
        })
    })
})
module.exports = adminRouter;
const { Op } = require('sequelize')//nodejs的sequelize模块
const express = require('express')//express框架
const customer = require('../crud/table/customer.js')//引入用户表
const customerRouter = express.Router()//express路由
customerRouter.post('/add',(req,res) =>{//用户注册
    const { customerIdCard, customerName, customerSex, customerPhoneNumber } = req.body;
    customer.findOne({
        where:{
            customerIdCard
        }
    })
    .then(data =>{
        if(data){
            res.status(200).json({
                success:false,
                msg:'该用户已经注册！'
            })
            return new Promise(() =>{})
        }else{
            return customer.create({
                customerIdCard, customerName, customerSex, customerPhoneNumber
            })
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'用户信息录入成功！',
            customer:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'内部服务器错误！'
        })
    })
})
// customerRouter.get('/login',(req,res) =>{//用户登录
//     const { customerIdCard, cust}
// })
customerRouter.put('/update',(req,res) =>{//用户基本信息修改
    const { customerIdCard, customerName, customerSex, customerPhoneNumber } = req.body;
    customer.findOne({
        where:{
            customerIdCard:{
                [Op.eq]:customerIdCard
            }
        }
    })
    .then(data =>{
        if(data){
            return customer.update({
                customerName, customerSex, customerPhoneNumber
            },{
               where:{
                    customerIdCard:{
                        [Op.eq]:customerIdCard
                    }
               }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该用户还未注册！'
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'用户信息修改成功！',
            customer:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器出错！'
        })
    }) 
}) 
customerRouter.delete('/del',(req,res) =>{//删除用户
    const { customerIdCard } = req.body;
    customer.destroy({
        where:{
            customerIdCard
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'用户删除成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
customerRouter.put('/updatevip',(req,res) =>{//购买会员
    const { customerIdCard, level } = req.body;
    customer.findOne({
        where:{
            customerIdCard
        }
    })
    .then(data =>{
        if(data){
            return customer.update({
                level
            },{
                where:{
                    customerIdCard
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该用户未注册！'
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        return customer.findOne({
            where:{
                customerIdCard
            }
        })
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'vip更改成功！',
            customer:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
customerRouter.put('/updatemoney',(req,res) =>{//修改用户总消费金额
    const { customerIdCard, money} = req.body;
    customer.findOne({
        where:{
            customerIdCard
        }
    })
    .then(data =>{
        if(data){
            let oldMoney = data.get().totalAmount;
            let newMoney = oldMoney + money;
            return customer.update({
                totalAmount: newMoney
            },{
                where:{
                    customerIdCard
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该用户为注册！'
            })
        }
    })
    .then(data =>{
        return customer.findOne({
            where:{
                customerIdCard
            }
        })
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'用户消费金额修改成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
customerRouter.get('/getAllCustomer',(req,res) =>{//查询所有顾客
    customer.findAndCountAll()
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'顾客信息查询成功！',
            customerList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器出错！'
        })
    })
})
customerRouter.get('/queryCustomer',(req,res) =>{//模糊查询顾客信息
    const { queryName } = req.query;
    customer.findAndCountAll({
        where:{
            customerName:{
                [Op.like]:'%'+queryName+'%'
            }
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'顾客信息查询成功！',
            customerList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .then(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器出错！'
        })
    })
})
module.exports = customerRouter;
const express = require('express')//express框架
const { Op } = require('sequelize')//nodejs的sequelize模块
const order = require('../crud/table/myorder.js')//引入订单信息表
const customer = require('../crud/table/customer.js')//引入顾客信息表
const room = require('../crud/table/room.js')//引入房间信息表
order.hasOne(customer,{ sourceKey:'customerIdCard', foreignKey:'customerIdCard' })
order.hasOne(room,{ sourceKey:'roomNumber', foreignKey:'roomNumber' })
const orderRouter = express.Router()
orderRouter.post('/add',(req,res) =>{//创建订单
    console.log(req.body)
    const { orderNumber, orderStatus,customerIdCard,roomNumber,
            checkInTime,checkOutTime,totalMoney,remarks
        } = req.body;
    order.findOne({
        where:{
            orderNumber
        }
    })
    .then(data =>{
        if(data){
            res.status(200).json({
                success:false,
                msg:'该订单已经存在！'
            })
            return new Promise(() =>{})
        }else{
            return customer.findOne({
                where:{
                    customerIdCard
                }
            })
        }
    })
    .then(data =>{
        if(data){
            return room.update({
                    roomStatus:'已入住'
            },{
                where:{
                        roomNumber
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该用户还未注册！'
            });
            return new Promise(() =>{});
        }
    })
    .then(data =>{
        return order.create({
            orderNumber, orderStatus,customerIdCard,roomNumber,
            checkInTime,checkOutTime,totalMoney,remarks
        })
    })
    .then(data =>{
        res.status(200).json({
            success:'true',
            msg:'订单创建成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'内部服务器出错！'
        })
    })
})
orderRouter.delete('/del',(req,res) =>{//删除订单
    const { orderNumber } = req.body;
    order.findOne({
        where:{
            orderNumber
        }
    })
    .then(data =>{
        if(data){
            return order.destroy({
                where:{
                    orderNumber
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该订单不存在！'
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'删除成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
orderRouter.put('/update',(req,res) =>{//修改订单状态
    const { orderStatus, orderNumber,totalMoney,roomNumber } = req.body;
    order.findOne({
        where:{
            orderNumber
        }
    })
    .then(data =>{
        if(data){
            return room.update({
                roomStatus:'未入住'
            },{
                where:{
                    roomNumber
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该订单不存在！'                
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        return order.update({
            orderStatus,totalMoney
        },{
            where:{
                orderNumber
            }
        })
    })
    .then(data =>{
        return order.findOne({
            where:{
                orderNumber
            }
        })
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'订单修改成功！',
            order:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
orderRouter.get('/getAllOrder',(req,res) =>{//查询所有订单
    const { pageSize, offset } = req.query;
    order.findAndCountAll({
        limit:pageSize,
        offset:offset,
        include:[
            {
                model:customer,
                foreignKey:'customerIdCard',
                attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
            },
            {
                model:room,
                foreignKey:'roomNumber',
                attributes:['type','remarks']
            }
        ]
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'所有订单查询成功！',
            orderList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误!'
        })
    })
})
orderRouter.get('/getAllNotPayOrder',(req,res) =>{//查询所有未支付的订单
    const { pageSize, offset } = req.query;
    order.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            orderStatus:{
                [Op.eq]:'未支付'
            }
        },
        include:[
            {
                model:customer,
                foreignKey:'customerIdCard',
                attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
            },
            {
                model:room,
                foreignKey:'roomNumber',
                attributes:['type']
            }
        ]
    })
    .then(data  =>{
        res.status(200).json({
            success:true,
            msg:'未支付订单查询成功！',
            orderList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count,
            pageSize:pageSize,
            offset:offset
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
orderRouter.get('/getAllPayOrder',(req,res) =>{//查询所有已支付的订单
    const { pageSize, offset } = req.query;
    order.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            orderStatus:{
                [Op.eq]:'已支付'
            }
        },
        include:[
            {
                model:customer,
                foreignKey:'customerIdCard',
                attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
            },
            {
                model:room,
                foreignKey:'roomNumber',
                attributes:['type']
            }
        ]
    })
    .then(data  =>{
        res.status(200).json({
            success:true,
            msg:'未支付订单查询成功！',
            orderList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count,
            pageSize:pageSize,
            offset:offset
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
orderRouter.get('/getStatusOrder',(req,res) =>{//查询所有该状态的订单
    const { pageSize, offset, orderStatus } = req.query;
    order.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            orderStatus:{
                [Op.eq]:orderStatus
            }
        },
        include:[
            {
                model:customer,
                foreignKey:'customerIdCard',
                attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
            },
            {
                model:room,
                foreignKey:'roomNumber',
                attributes:['type']
            }
        ]
    })
    .then(data  =>{
        res.status(200).json({
            success:true,
            msg:'状态订单查询成功！',
            orderList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count,
            pageSize:pageSize,
            offset:offset
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
module.exports = orderRouter;
const express = require('express')//express框架
const { Op } = require('sequelize')//nodejs的sequelize模块
const room = require('../crud/table/room.js')//引入放假信息表
const roomType = require('../crud/table/roomType.js')//引入所有房间类型表
room.hasOne(roomType,{ sourceKey:'type',foreignKey:'type'})//每个房间都有一个房间类型
const roomRouter = express.Router()
roomRouter.post('/add',(req,res) =>{//添加房间
    const { roomNumber, type, roomStatus, remarks } = req.body;
    room.findOne({
        where:{
            roomNumber
        }
    })
    .then(data =>{
        if(data){
            res.status(200).json({
                success:false,
                msg:'该房间已经存在！'
            })
            return new Promise(() =>{})
        }else{
            return room.create({
                roomNumber, type, roomStatus, remarks
            })
        }
    })
    .then(data =>{
        return room.findOne({
            where:{
                roomNumber
            },
            include:[{
                model:roomType,
                foreignKey:'type',
                attributes:['price','url']
            }]
        })
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'房间添加成功！',
            room:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.delete('/del',(req,res) =>{
    const { roomNumber } = req.body;
    room.findOne({
        where:{
            roomNumber
        }
    })
    .then(data =>{
        if(data){
            return room.destroy({
                where:{
                    roomNumber
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'房间删除失败！'
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'该房间删除成功！'
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.put('/update',(req,res) =>{//修改房间信息
    const { roomNumber, type, roomStatus,remarks } = req.body;
    room.findOne({
        where:{
            roomNumber
        }
    })
    .then(data =>{
        if(data){
            return room.update({
                type, roomStatus,remarks
            },{
                where:{
                    roomNumber
                }
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'该房间不存在！'
            })
            return new Promise(() =>{})
        }
    })
    .then(data =>{
        return room.findOne({
            where:{
                roomNumber
            }
        })
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'房间信息修改成功！',
            room:data.get()
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误'
        })
    })
})
roomRouter.get('/getAllRoom',(req,res) =>{//获取所有房间信息
    const { pageSize, offset } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset
    })
    .then(data =>{
        let roomList = data.rows.map(item =>{
            return item.get()
        })
        res.status(200).json({
            success:true,
            msg:'房间信息查询成功！',
            roomList:roomList,
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.get('/getOneRoom',(req,res) =>{//获取某个房间号的房间信息
    const { roomNumber } = req.query;
    room.findOne({
        where:{
            roomNumber
        }
    })
    .then(data =>{
        if(data){
            res.status(200).json({
                success:true,
                msg:'房间查询成功！',
                room:data.get()
            })
        }else{
            res.status(200).json({
                success:false,
                msg:'未查询到该房间信息'
            })
        }
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.get('/getNotInRoom',(req,res) =>{//获取未入住房间信息
    const { pageSize, offset } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            roomStatus:{
                [Op.eq]:'未入住'
            }
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'未入住房间查询成功!',
            roomList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.get('/getInRoom',(req,res) =>{//查询已入住房间信息
    const { pageSize, offset } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            roomStatus:{
                [Op.eq]:'已入住'
            }
        }
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'已入住房间查询成功！',
            roomList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.get('/getAllRoomPrice',(req,res) =>{//查询所有的房间以及价格
    const { pageSize, offset } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset,
        include:[{
            model:roomType,
            foreignKey:'type',
            attributes:['price','url']
        }]
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'房间信息查询成功!',
            roomList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器内部错误！'
        })
    })
})
roomRouter.get('/getAllNotINRoomPrice',(req,res) =>{//获取所有未入住的房间信息
    const { pageSize, offset } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            roomStatus:{
                [Op.eq]:'未入住'
            }
        },
        include:[{
            model:roomType,
            foreignKey:'type',
            attributes:['price','url']
        }]
    })
    .then(data =>{
       res.status(200).json({
           success:true,
           msg:'房间信息查询成功！',
           roomList:data.rows.map(item =>{
               return item.get()
           }),
           count:data.count
       })
    })
})
roomRouter.get('/getAllINRoomPrice',(req,res) =>{//获取所有已入住的房间信息
    const { pageSize, offset } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            roomStatus:{
                [Op.eq]:'已入住'
            }
        },
        include:[{
            model:roomType,
            foreignKey:'type',
            attributes:['price','url']
        }]
    })
    .then(data =>{
       res.status(200).json({
           success:true,
           msg:'房间信息查询成功！',
           roomList:data.rows.map(item =>{
               return item.get()
           }),
           count:data.count
       })
    })
})
roomRouter.get('/getAllRoomTypePrice',(req,res) =>{
    const { pageSize, offset, type } = req.query;
    room.findAndCountAll({
        where:{
           type:{
               [Op.eq]:type
           }
        },
        include:[{
            model:roomType,
            foreignKey:'type',
            attributes:['price','url']
        }]
    })
    .then(data =>{
        res.status(200).json({
            success:true,
            msg:'房型查询成功！',
            roomList:data.rows.map(item =>{
                return item.get()
            }),
            count:data.count
        })
    })
    .catch(err =>{
        res.status(200).json({
            success:false,
            msg:'服务器出错！'
        })
    })
})
roomRouter.get('/getAllStatusRoom',(req,res) =>{//获取所有该状态的房间信息
    const { pageSize, offset, roomStatus } = req.query;
    room.findAndCountAll({
        limit:pageSize,
        offset:offset,
        where:{
            roomStatus:{
                [Op.eq]:roomStatus
            }
        },
        include:[{
            model:roomType,
            foreignKey:'type',
            attributes:['price','url']
        }]
    })
    .then(data =>{
       res.status(200).json({
           success:true,
           msg:'房间信息查询成功！',
           roomList:data.rows.map(item =>{
               return item.get()
           }),
           count:data.count
       })
    })
})
module.exports = roomRouter

五，项目总结

文章标签：
JavaScript
前端开发
数据库
API
关系型数据库
关键词：
Node.js开发
node.js系统
VUE.js开发
node.js vue
VUE.js管理系统
编程指南针
目录
相关文章
sunrr
|
13天前
|
Web App开发 JavaScript 前端开发
Node.js开发
Node.js开发
sunrr
31 13
肥猪肥猪-17824
|
19天前
|
存储 JavaScript 前端开发
深入浅出Node.js后端开发
在数字化时代的浪潮中，后端开发作为连接用户与数据的桥梁，扮演着至关重要的角色。本文将以Node.js为例，深入探讨其背后的哲学思想、核心特性以及在实际项目中的应用，旨在为读者揭示Node.js如何优雅地处理高并发请求，并通过实践案例加深理解。无论你是初学者还是有一定经验的开发者，这篇文章都将为你提供新的视角和思考。
肥猪肥猪-17824
26 7
肥猪肥猪-17824
|
16天前
|
Web App开发 开发框架 JavaScript
深入浅出Node.js后端开发
本文将带你领略Node.js的魅力，从基础概念到实践应用，一步步深入理解并掌握Node.js在后端开发中的运用。我们将通过实例学习如何搭建一个基本的Web服务，探讨Node.js的事件驱动和非阻塞I/O模型，以及如何利用其强大的生态系统进行高效的后端开发。无论你是前端开发者还是后端新手，这篇文章都会为你打开一扇通往全栈开发的大门。
肥猪肥猪-17824
24 3
游客moiomvrp3vyac2
|
16天前
|
Web App开发 JavaScript 前端开发
深入浅出Node.js后端开发
本文将带领读者从零基础开始，一步步深入到Node.js后端开发的精髓。我们将通过通俗易懂的语言和实际代码示例，探索Node.js的强大功能及其在现代Web开发中的应用。无论你是初学者还是有一定经验的开发者，这篇文章都将为你提供新的见解和技巧，让你的后端开发技能更上一层楼。
游客moiomvrp3vyac2
23 1
游客moiomvrp3vyac2
|
19天前
|
JavaScript 前端开发 API
深入理解Node.js事件循环及其在后端开发中的应用
本文旨在揭示Node.js的核心特性之一——事件循环，并探讨其对后端开发实践的深远影响。通过剖析事件循环的工作原理和关键组件，我们不仅能够更好地理解Node.js的非阻塞I/O模型，还能学会如何优化我们的后端应用以提高性能和响应能力。文章将结合实例分析事件循环在处理大量并发请求时的优势，以及如何避免常见的编程陷阱，从而为读者提供从理论到实践的全面指导。
游客moiomvrp3vyac2
25 4
航空母舰
|
Java Shell JavaScript
Node 在各系统的安装
航空母舰
1445 0
雨溪-yuxi
|
25天前
|
Web App开发 JavaScript 前端开发
2024年5月node.js安装(winmac系统)保姆级教程
本篇博客为2024年5月版Node.js安装教程，适用于Windows和Mac系统。作者是一名熟悉JavaScript与Vue的大一学生，分享了Node.js的基本介绍、下载链接及简单安装步骤。安装完成后，通过终端命令`node -v`验证版本即可确认安装成功。欢迎关注作者，获取更多技术文章。
雨溪-yuxi
26 2
2024年5月node.js安装(winmac系统)保姆级教程
那年春天
|
23天前
|
存储 JavaScript 搜索推荐
Node框架的安装和配置方法
安装 Node 框架是进行 Node 开发的第一步，通过正确的安装和配置，可以为后续的开发工作提供良好的基础。在安装过程中，需要仔细阅读相关文档和提示，遇到问题及时解决，以确保安装顺利完成。
那年春天
74 2
杀死一只知更鸟debug
|
3月前
|
JavaScript
NodeJs的安装
文章介绍了Node.js的安装步骤和如何创建第一个Node.js应用。包括从官网下载安装包、安装过程、验证安装是否成功，以及使用Node.js监听端口构建简单服务器的示例代码。
杀死一只知更鸟debug
106 1
NodeJs的安装
你都不懂
|
2月前
|
JavaScript 开发工具 git
已安装nodejs但是安装hexo报错
已安装nodejs但是安装hexo报错
你都不懂
38 2

热门文章

最新文章

  • 1
    3. VPP源码分析（graph node(1))
  • 2
    Node.js 中流操作实践
  • 3
    node工具模块
  • 4
    【nodejs】让nodejs像后端mvc框架（asp.net mvc ）一样处理请求--路由限制及选择篇（2/8）【route】
  • 5
    node.js入门学习
  • 6
    Node.js开发环境部署
  • 7
    Nodejs·进程
  • 8
    node 阻塞和非阻塞
  • 9
    Node 项目通过 .npmrc 文件指定依赖安装源
  • 10
    Node.js开发者有福了！Express 3.0发布
  • 1
    Vue.js组件通信策略详解
    60
  • 2
    在 JeecgBoot 项目中基于 Vue 3 配置多页面入口
    125
  • 3
    前端框架与库 - Vue.js 组件与路由
    55
  • 4
    vue代码优化方案
    61
  • 5
    前端框架与库 - Vue.js基础：模板语法、数据绑定
    166
  • 6
    在Vue中，子组件向父组件传递数据
    83
  • 7
    【vue3】Argumnt of type ‘history:RouterHistory；}is not assignable to paraeter of type ‘RouterOptions‘.
    103
  • 8
    【vue3】vue3中路由hash与History的设置
    260
  • 9
    【Vue3】解决电脑分辨率125%、150%及缩放导致页面变形的问题
    1263
  • 10
    【vue】 el-table解决分页不能筛选全部数据的问题
    542

    • 相关课程

    更多
  • Spring Boot+Vue.js+FastDFS实现分布式图片服务器
  • Node.js 入门与实战
  • Vue.js 入门与实战
  • Vue.js完全自学手册图文教程
  • Node.js 入门教程文档
  • React 入门教程开发文档

    • 相关电子书

    更多
  • 探究 Node.js 的服务端之路
  • 个推微服务实践 基于OpenResty 和Node.js
  • 沪江基于Node.js大规模应用实践

    • 相关实验场景

    更多
  • 前端开发基础6：Node.js和LESS预编译工具
  • 搭建Node.js编程环境
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解