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

    作者主页：编程千纸鹤

    作者简介：Java、前端、Pythone开发多年，做过高程，项目经理，架构师

    主要内容：Java项目开发、毕业设计开发、面试技术整理、最新技术分享

    项目编号：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

    三，系统展示

    用户注册

    用户登陆

    房间管理

    房型管理

    订单管理

    订单管理

    四，核心代码展示

    1. const { Op } = require('sequelize')//nodejs的sequelize模块
    2. const express = require('express')//express框架
    3. const admin = require('../crud/table/admin.js')//引入管理员信息表
    4. const token = require('../comment/token.js')//引入token模块
    5. const adminRouter = express.Router()//express路由
    6.  
    7. adminRouter.post('/register',(req,res) =>{//管理员注册
    8.     const { adminId, adminName, adminPassword } = req.body;
    9.     admin.findOne({
    10.         where:{
    11.             adminId:adminId
    12.         }
    13.     })
    14.     .then(data =>{
    15.         if(data){
    16.             res.status(200).json({
    17.                 msg:'该用户已经注册',
    18.                 success:false
    19.             })
    20.             return new Promise(() =>{})
    21.         }else{
    22.             return admin.create({
    23.                 adminId, adminName, adminPassword
    24.             })
    25.         }
    26.     })
    27.     .then(data =>{
    28.         res.status(200).json({
    29.             success:true,
    30.             msg:'管理员注册成功！',
    31.             admin:data.get()
    32.         })
    33.     })
    34.     .catch(err =>{
    35.         res.status(200).json({
    36.             success:false,
    37.             msg:'内部服务器错误！'
    38.         })
    39.     })
    40.  
    41. })
    42.  
    43. adminRouter.get('/login',(req,res) =>{//登录
    44.     const { adminId, adminPassword } = req.query;
    45.     let adminInfo;
    46.     admin.findOne({
    47.         where:{
    48.             adminId
    49.         }
    50.     })
    51.     .then(data =>{
    52.         if(data){
    53.             if(data.get().adminPassword==adminPassword){
    54.                 adminInfo = data.get();
    55.                 return token.setToken(data.get())
    56.             }else{
    57.                 res.status(200).json({
    58.                     success:false,
    59.                     msg:'用户密码错误！'
    60.                 });  
    61.                 return new Promise(() =>{})
    62.             }
    63.         }else{
    64.            res.status(200).json({
    65.                success:false,
    66.                msg:'该用户还未注册！'
    67.            })
    68.            return new Promise(() =>{})
    69.         }
    70.     })
    71.     .then(data =>{
    72.         res.status(200).json({
    73.             success:true,
    74.             admin:adminInfo,
    75.             token:data,
    76.             msg:'登录成功！'
    77.         })
    78.     })
    79.     .catch(err =>{
    80.         res.status(200).json({
    81.             success:false,
    82.             msg:'内部服务器出错！'
    83.         })
    84.     })
    85. })
    86.  
    87. adminRouter.put('/update',(req,res) =>{//修改管理员信息
    88.     const { adminId, adminName, adminPassword, adminSex, adminAge } = req.body;
    89.     admin.findOne({
    90.         where:{
    91.             adminId,adminPassword
    92.         }
    93.     })
    94.     .then(data =>{
    95.         if(data){
    96.            return admin.update({
    97.                     adminName,adminSex,adminAge
    98.                 },{
    99.                     where:{
    100.                         adminId,adminPassword
    101.                     }
    102.                 })
    103.         }else{
    104.             res.status(200).json({
    105.                 success:false,
    106.                 msg:'管理员账号或者密码错误！'
    107.             })
    108.             return new Promise(() =>{})
    109.         }
    110.     })
    111.     .then(data =>{
    112.         return admin.findOne({
    113.             where:{
    114.                 adminId,adminPassword
    115.             }
    116.         })
    117.     })
    118.     .then(data =>{
    119.         res.status(200).json({
    120.             success:true,
    121.             msg:'管理员信息修改成功！',
    122.             admin:data.get()
    123.         })
    124.     })
    125.     .catch(err =>{
    126.         res.status(200).json({
    127.             success:false,
    128.             msg:'服务器内部错误!'
    129.         })
    130.     })
    131. })
    132.  
    133. adminRouter.delete('/del',(req,res) =>{
    134.     const { adminId } = req.body || req.query;
    135.     admin.destroy({
    136.         where:{
    137.             adminId
    138.         }
    139.     })
    140.     .then(data =>{
    141.         res.status(200).json({
    142.             success:true,
    143.             msg:'删除成功！'
    144.         })
    145.     })
    146.     .catch(err =>{
    147.         res.status(200).json({
    148.             success:false,
    149.             msg:'删除失败!'
    150.         })
    151.     })
    152. })
    153.  
    154. module.exports = adminRouter;

    1. const { Op } = require('sequelize')//nodejs的sequelize模块
    2. const express = require('express')//express框架
    3. const customer = require('../crud/table/customer.js')//引入用户表
    4.  
    5. const customerRouter = express.Router()//express路由
    6.  
    7. customerRouter.post('/add',(req,res) =>{//用户注册
    8.     const { customerIdCard, customerName, customerSex, customerPhoneNumber } = req.body;
    9.     customer.findOne({
    10.         where:{
    11.             customerIdCard
    12.         }
    13.     })
    14.     .then(data =>{
    15.         if(data){
    16.             res.status(200).json({
    17.                 success:false,
    18.                 msg:'该用户已经注册！'
    19.             })
    20.             return new Promise(() =>{})
    21.         }else{
    22.             return customer.create({
    23.                 customerIdCard, customerName, customerSex, customerPhoneNumber
    24.             })
    25.         }
    26.     })
    27.     .then(data =>{
    28.         res.status(200).json({
    29.             success:true,
    30.             msg:'用户信息录入成功！',
    31.             customer:data.get()
    32.         })
    33.     })
    34.     .catch(err =>{
    35.         res.status(200).json({
    36.             success:false,
    37.             msg:'内部服务器错误！'
    38.         })
    39.     })
    40. })
    41.  
    42. // customerRouter.get('/login',(req,res) =>{//用户登录
    43. //     const { customerIdCard, cust}
    44. // })
    45.  
    46. customerRouter.put('/update',(req,res) =>{//用户基本信息修改
    47.     const { customerIdCard, customerName, customerSex, customerPhoneNumber } = req.body;
    48.     customer.findOne({
    49.         where:{
    50.             customerIdCard:{
    51.                 [Op.eq]:customerIdCard
    52.             }
    53.         }
    54.     })
    55.     .then(data =>{
    56.         if(data){
    57.             return customer.update({
    58.                 customerName, customerSex, customerPhoneNumber
    59.             },{
    60.                where:{
    61.                     customerIdCard:{
    62.                         [Op.eq]:customerIdCard
    63.                     }
    64.                }
    65.             })
    66.         }else{
    67.             res.status(200).json({
    68.                 success:false,
    69.                 msg:'该用户还未注册！'
    70.             })
    71.             return new Promise(() =>{})
    72.         }
    73.     })
    74.     .then(data =>{
    75.         res.status(200).json({
    76.             success:true,
    77.             msg:'用户信息修改成功！',
    78.             customer:data.get()
    79.         })
    80.     })
    81.     .catch(err =>{
    82.         res.status(200).json({
    83.             success:false,
    84.             msg:'服务器出错！'
    85.         })
    86.     }) 
    87. }) 
    88.  
    89. customerRouter.delete('/del',(req,res) =>{//删除用户
    90.     const { customerIdCard } = req.body;
    91.     customer.destroy({
    92.         where:{
    93.             customerIdCard
    94.         }
    95.     })
    96.     .then(data =>{
    97.         res.status(200).json({
    98.             success:true,
    99.             msg:'用户删除成功！'
    100.         })
    101.     })
    102.     .catch(err =>{
    103.         res.status(200).json({
    104.             success:false,
    105.             msg:'服务器内部错误！'
    106.         })
    107.     })
    108. })
    109.  
    110. customerRouter.put('/updatevip',(req,res) =>{//购买会员
    111.     const { customerIdCard, level } = req.body;
    112.     customer.findOne({
    113.         where:{
    114.             customerIdCard
    115.         }
    116.     })
    117.     .then(data =>{
    118.         if(data){
    119.             return customer.update({
    120.                 level
    121.             },{
    122.                 where:{
    123.                     customerIdCard
    124.                 }
    125.             })
    126.         }else{
    127.             res.status(200).json({
    128.                 success:false,
    129.                 msg:'该用户未注册！'
    130.             })
    131.             return new Promise(() =>{})
    132.         }
    133.     })
    134.     .then(data =>{
    135.         return customer.findOne({
    136.             where:{
    137.                 customerIdCard
    138.             }
    139.         })
    140.     })
    141.     .then(data =>{
    142.         res.status(200).json({
    143.             success:true,
    144.             msg:'vip更改成功！',
    145.             customer:data.get()
    146.         })
    147.     })
    148.     .catch(err =>{
    149.         res.status(200).json({
    150.             success:false,
    151.             msg:'服务器内部错误！'
    152.         })
    153.     })
    154.  
    155. })
    156.  
    157.  
    158. customerRouter.put('/updatemoney',(req,res) =>{//修改用户总消费金额
    159.     const { customerIdCard, money} = req.body;
    160.     customer.findOne({
    161.         where:{
    162.             customerIdCard
    163.         }
    164.     })
    165.     .then(data =>{
    166.         if(data){
    167.             let oldMoney = data.get().totalAmount;
    168.             let newMoney = oldMoney + money;
    169.             return customer.update({
    170.                 totalAmount: newMoney
    171.             },{
    172.                 where:{
    173.                     customerIdCard
    174.                 }
    175.             })
    176.         }else{
    177.             res.status(200).json({
    178.                 success:false,
    179.                 msg:'该用户为注册！'
    180.             })
    181.         }
    182.     })
    183.     .then(data =>{
    184.         return customer.findOne({
    185.             where:{
    186.                 customerIdCard
    187.             }
    188.         })
    189.     })
    190.     .then(data =>{
    191.         res.status(200).json({
    192.             success:true,
    193.             msg:'用户消费金额修改成功！'
    194.         })
    195.     })
    196.     .catch(err =>{
    197.         res.status(200).json({
    198.             success:false,
    199.             msg:'服务器内部错误！'
    200.         })
    201.     })
    202.  
    203. })
    204.  
    205. customerRouter.get('/getAllCustomer',(req,res) =>{//查询所有顾客
    206.     customer.findAndCountAll()
    207.     .then(data =>{
    208.         res.status(200).json({
    209.             success:true,
    210.             msg:'顾客信息查询成功！',
    211.             customerList:data.rows.map(item =>{
    212.                 return item.get()
    213.             }),
    214.             count:data.count
    215.         })
    216.     })
    217.     .catch(err =>{
    218.         res.status(200).json({
    219.             success:false,
    220.             msg:'服务器出错！'
    221.         })
    222.     })
    223. })
    224.  
    225. customerRouter.get('/queryCustomer',(req,res) =>{//模糊查询顾客信息
    226.     const { queryName } = req.query;
    227.     customer.findAndCountAll({
    228.         where:{
    229.             customerName:{
    230.                 [Op.like]:'%'+queryName+'%'
    231.             }
    232.         }
    233.     })
    234.     .then(data =>{
    235.         res.status(200).json({
    236.             success:true,
    237.             msg:'顾客信息查询成功！',
    238.             customerList:data.rows.map(item =>{
    239.                 return item.get()
    240.             }),
    241.             count:data.count
    242.         })
    243.     })
    244.     .then(err =>{
    245.         res.status(200).json({
    246.             success:false,
    247.             msg:'服务器出错！'
    248.         })
    249.     })
    250. })
    251.  
    252. module.exports = customerRouter;
    1. const express = require('express')//express框架
    2. const { Op } = require('sequelize')//nodejs的sequelize模块
    3. const order = require('../crud/table/myorder.js')//引入订单信息表
    4. const customer = require('../crud/table/customer.js')//引入顾客信息表
    5. const room = require('../crud/table/room.js')//引入房间信息表
    6.  
    7. order.hasOne(customer,{ sourceKey:'customerIdCard', foreignKey:'customerIdCard' })
    8. order.hasOne(room,{ sourceKey:'roomNumber', foreignKey:'roomNumber' })
    9.  
    10. const orderRouter = express.Router()
    11.  
    12. orderRouter.post('/add',(req,res) =>{//创建订单
    13.     console.log(req.body)
    14.     const { orderNumber, orderStatus,customerIdCard,roomNumber,
    15.             checkInTime,checkOutTime,totalMoney,remarks
    16.         } = req.body;
    17.     order.findOne({
    18.         where:{
    19.             orderNumber
    20.         }
    21.     })
    22.     .then(data =>{
    23.         if(data){
    24.             res.status(200).json({
    25.                 success:false,
    26.                 msg:'该订单已经存在！'
    27.             })
    28.             return new Promise(() =>{})
    29.         }else{
    30.             return customer.findOne({
    31.                 where:{
    32.                     customerIdCard
    33.                 }
    34.             })
    35.         }
    36.     })
    37.     .then(data =>{
    38.         if(data){
    39.             return room.update({
    40.                     roomStatus:'已入住'
    41.             },{
    42.                 where:{
    43.                         roomNumber
    44.                 }
    45.             })
    46.         }else{
    47.             res.status(200).json({
    48.                 success:false,
    49.                 msg:'该用户还未注册！'
    50.             });
    51.             return new Promise(() =>{});
    52.         }
    53.        
    54.     })
    55.     .then(data =>{
    56.         return order.create({
    57.             orderNumber, orderStatus,customerIdCard,roomNumber,
    58.             checkInTime,checkOutTime,totalMoney,remarks
    59.         })
    60.     })
    61.     .then(data =>{
    62.         res.status(200).json({
    63.             success:'true',
    64.             msg:'订单创建成功！'
    65.         })
    66.     })
    67.     .catch(err =>{
    68.         res.status(200).json({
    69.             success:false,
    70.             msg:'内部服务器出错！'
    71.         })
    72.     })
    73. })
    74.  
    75. orderRouter.delete('/del',(req,res) =>{//删除订单
    76.     const { orderNumber } = req.body;
    77.     order.findOne({
    78.         where:{
    79.             orderNumber
    80.         }
    81.     })
    82.     .then(data =>{
    83.         if(data){
    84.             return order.destroy({
    85.                 where:{
    86.                     orderNumber
    87.                 }
    88.             })
    89.         }else{
    90.             res.status(200).json({
    91.                 success:false,
    92.                 msg:'该订单不存在！'
    93.             })
    94.             return new Promise(() =>{})
    95.         }
    96.     })
    97.     .then(data =>{
    98.         res.status(200).json({
    99.             success:true,
    100.             msg:'删除成功！'
    101.         })
    102.     })
    103.     .catch(err =>{
    104.         res.status(200).json({
    105.             success:false,
    106.             msg:'服务器内部错误！'
    107.         })
    108.     })
    109. })
    110.  
    111. orderRouter.put('/update',(req,res) =>{//修改订单状态
    112.     const { orderStatus, orderNumber,totalMoney,roomNumber } = req.body;
    113.     order.findOne({
    114.         where:{
    115.             orderNumber
    116.         }
    117.     })
    118.     .then(data =>{
    119.         if(data){
    120.             return room.update({
    121.                 roomStatus:'未入住'
    122.             },{
    123.                 where:{
    124.                     roomNumber
    125.                 }
    126.             })
    127.         }else{
    128.             res.status(200).json({
    129.                 success:false,
    130.                 msg:'该订单不存在！'                
    131.             })
    132.             return new Promise(() =>{})
    133.         }
    134.     })
    135.     .then(data =>{
    136.         return order.update({
    137.             orderStatus,totalMoney
    138.         },{
    139.             where:{
    140.                 orderNumber
    141.             }
    142.         })
    143.        
    144.     })
    145.     .then(data =>{
    146.         return order.findOne({
    147.             where:{
    148.                 orderNumber
    149.             }
    150.         })
    151.     })
    152.     .then(data =>{
    153.         res.status(200).json({
    154.             success:true,
    155.             msg:'订单修改成功！',
    156.             order:data.get()
    157.         })
    158.     })
    159.     .catch(err =>{
    160.         res.status(200).json({
    161.             success:false,
    162.             msg:'服务器内部错误！'
    163.         })
    164.     })
    165.  
    166. })
    167.  
    168. orderRouter.get('/getAllOrder',(req,res) =>{//查询所有订单
    169.     const { pageSize, offset } = req.query;
    170.     order.findAndCountAll({
    171.         limit:pageSize,
    172.         offset:offset,
    173.         include:[
    174.             {
    175.                 model:customer,
    176.                 foreignKey:'customerIdCard',
    177.                 attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
    178.             },
    179.             {
    180.                 model:room,
    181.                 foreignKey:'roomNumber',
    182.                 attributes:['type','remarks']
    183.             }
    184.         ]
    185.     })
    186.     .then(data =>{
    187.         res.status(200).json({
    188.             success:true,
    189.             msg:'所有订单查询成功！',
    190.             orderList:data.rows.map(item =>{
    191.                 return item.get()
    192.             }),
    193.             count:data.count
    194.         })
    195.     })
    196.     .catch(err =>{
    197.         res.status(200).json({
    198.             success:false,
    199.             msg:'服务器内部错误!'
    200.         })
    201.     })
    202. })
    203.  
    204. orderRouter.get('/getAllNotPayOrder',(req,res) =>{//查询所有未支付的订单
    205.     const { pageSize, offset } = req.query;
    206.     order.findAndCountAll({
    207.         limit:pageSize,
    208.         offset:offset,
    209.         where:{
    210.             orderStatus:{
    211.                 [Op.eq]:'未支付'
    212.             }
    213.         },
    214.         include:[
    215.             {
    216.                 model:customer,
    217.                 foreignKey:'customerIdCard',
    218.                 attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
    219.             },
    220.             {
    221.                 model:room,
    222.                 foreignKey:'roomNumber',
    223.                 attributes:['type']
    224.             }
    225.         ]
    226.     })
    227.     .then(data  =>{
    228.         res.status(200).json({
    229.             success:true,
    230.             msg:'未支付订单查询成功！',
    231.             orderList:data.rows.map(item =>{
    232.                 return item.get()
    233.             }),
    234.             count:data.count,
    235.             pageSize:pageSize,
    236.             offset:offset
    237.         })
    238.     })
    239.     .catch(err =>{
    240.         res.status(200).json({
    241.             success:false,
    242.             msg:'服务器内部错误！'
    243.         })
    244.     })
    245. })
    246.  
    247. orderRouter.get('/getAllPayOrder',(req,res) =>{//查询所有已支付的订单
    248.     const { pageSize, offset } = req.query;
    249.     order.findAndCountAll({
    250.         limit:pageSize,
    251.         offset:offset,
    252.         where:{
    253.             orderStatus:{
    254.                 [Op.eq]:'已支付'
    255.             }
    256.         },
    257.         include:[
    258.             {
    259.                 model:customer,
    260.                 foreignKey:'customerIdCard',
    261.                 attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
    262.             },
    263.             {
    264.                 model:room,
    265.                 foreignKey:'roomNumber',
    266.                 attributes:['type']
    267.             }
    268.         ]
    269.     })
    270.     .then(data  =>{
    271.         res.status(200).json({
    272.             success:true,
    273.             msg:'未支付订单查询成功！',
    274.             orderList:data.rows.map(item =>{
    275.                 return item.get()
    276.             }),
    277.             count:data.count,
    278.             pageSize:pageSize,
    279.             offset:offset
    280.         })
    281.     })
    282.     .catch(err =>{
    283.         res.status(200).json({
    284.             success:false,
    285.             msg:'服务器内部错误！'
    286.         })
    287.     })
    288. })
    289.  
    290. orderRouter.get('/getStatusOrder',(req,res) =>{//查询所有该状态的订单
    291.     const { pageSize, offset, orderStatus } = req.query;
    292.     order.findAndCountAll({
    293.         limit:pageSize,
    294.         offset:offset,
    295.         where:{
    296.             orderStatus:{
    297.                 [Op.eq]:orderStatus
    298.             }
    299.         },
    300.         include:[
    301.             {
    302.                 model:customer,
    303.                 foreignKey:'customerIdCard',
    304.                 attributes:['customerName','customerSex','customerVipLevel','customerPhoneNumber','totalAmount']
    305.             },
    306.             {
    307.                 model:room,
    308.                 foreignKey:'roomNumber',
    309.                 attributes:['type']
    310.             }
    311.         ]
    312.     })
    313.     .then(data  =>{
    314.         res.status(200).json({
    315.             success:true,
    316.             msg:'状态订单查询成功！',
    317.             orderList:data.rows.map(item =>{
    318.                 return item.get()
    319.             }),
    320.             count:data.count,
    321.             pageSize:pageSize,
    322.             offset:offset
    323.         })
    324.     })
    325.     .catch(err =>{
    326.         res.status(200).json({
    327.             success:false,
    328.             msg:'服务器内部错误！'
    329.         })
    330.     })
    331. })
    332. module.exports = orderRouter;
    1. const express = require('express')//express框架
    2. const { Op } = require('sequelize')//nodejs的sequelize模块
    3. const room = require('../crud/table/room.js')//引入放假信息表
    4. const roomType = require('../crud/table/roomType.js')//引入所有房间类型表
    5.  
    6. room.hasOne(roomType,{ sourceKey:'type',foreignKey:'type'})//每个房间都有一个房间类型
    7.  
    8. const roomRouter = express.Router()
    9.  
    10. roomRouter.post('/add',(req,res) =>{//添加房间
    11.     const { roomNumber, type, roomStatus, remarks } = req.body;
    12.     room.findOne({
    13.         where:{
    14.             roomNumber
    15.         }
    16.     })
    17.     .then(data =>{
    18.         if(data){
    19.             res.status(200).json({
    20.                 success:false,
    21.                 msg:'该房间已经存在！'
    22.             })
    23.             return new Promise(() =>{})
    24.         }else{
    25.             return room.create({
    26.                 roomNumber, type, roomStatus, remarks
    27.             })
    28.         }
    29.     })
    30.     .then(data =>{
    31.         return room.findOne({
    32.             where:{
    33.                 roomNumber
    34.             },
    35.             include:[{
    36.                 model:roomType,
    37.                 foreignKey:'type',
    38.                 attributes:['price','url']
    39.             }]
    40.         })
    41.     })
    42.     .then(data =>{
    43.         res.status(200).json({
    44.             success:true,
    45.             msg:'房间添加成功！',
    46.             room:data.get()
    47.         })
    48.     })
    49.     .catch(err =>{
    50.         res.status(200).json({
    51.             success:false,
    52.             msg:'服务器内部错误！'
    53.         })
    54.     })
    55. })
    56.  
    57. roomRouter.delete('/del',(req,res) =>{
    58.     const { roomNumber } = req.body;
    59.     room.findOne({
    60.         where:{
    61.             roomNumber
    62.         }
    63.     })
    64.     .then(data =>{
    65.         if(data){
    66.             return room.destroy({
    67.                 where:{
    68.                     roomNumber
    69.                 }
    70.             })
    71.         }else{
    72.             res.status(200).json({
    73.                 success:false,
    74.                 msg:'房间删除失败！'
    75.             })
    76.             return new Promise(() =>{})
    77.         }
    78.     })
    79.     .then(data =>{
    80.         res.status(200).json({
    81.             success:true,
    82.             msg:'该房间删除成功！'
    83.         })
    84.     })
    85.     .catch(err =>{
    86.         res.status(200).json({
    87.             success:false,
    88.             msg:'服务器内部错误！'
    89.         })
    90.     })
    91. })
    92.  
    93. roomRouter.put('/update',(req,res) =>{//修改房间信息
    94.     const { roomNumber, type, roomStatus,remarks } = req.body;
    95.     room.findOne({
    96.         where:{
    97.             roomNumber
    98.         }
    99.     })
    100.     .then(data =>{
    101.         if(data){
    102.             return room.update({
    103.                 type, roomStatus,remarks
    104.             },{
    105.                 where:{
    106.                     roomNumber
    107.                 }
    108.             })
    109.         }else{
    110.             res.status(200).json({
    111.                 success:false,
    112.                 msg:'该房间不存在！'
    113.             })
    114.             return new Promise(() =>{})
    115.         }
    116.     })
    117.     .then(data =>{
    118.         return room.findOne({
    119.             where:{
    120.                 roomNumber
    121.             }
    122.         })
    123.     })
    124.     .then(data =>{
    125.         res.status(200).json({
    126.             success:true,
    127.             msg:'房间信息修改成功！',
    128.             room:data.get()
    129.         })
    130.     })
    131.     .catch(err =>{
    132.         res.status(200).json({
    133.             success:false,
    134.             msg:'服务器内部错误'
    135.         })
    136.     })
    137. })
    138.  
    139. roomRouter.get('/getAllRoom',(req,res) =>{//获取所有房间信息
    140.     const { pageSize, offset } = req.query;
    141.     room.findAndCountAll({
    142.         limit:pageSize,
    143.         offset:offset
    144.     })
    145.     .then(data =>{
    146.         let roomList = data.rows.map(item =>{
    147.             return item.get()
    148.         })
    149.         res.status(200).json({
    150.             success:true,
    151.             msg:'房间信息查询成功！',
    152.             roomList:roomList,
    153.             count:data.count
    154.         })
    155.     })
    156.     .catch(err =>{
    157.         res.status(200).json({
    158.             success:false,
    159.             msg:'服务器内部错误！'
    160.         })
    161.     })
    162. })
    163.  
    164. roomRouter.get('/getOneRoom',(req,res) =>{//获取某个房间号的房间信息
    165.     const { roomNumber } = req.query;
    166.     room.findOne({
    167.         where:{
    168.             roomNumber
    169.         }
    170.     })
    171.     .then(data =>{
    172.         if(data){
    173.             res.status(200).json({
    174.                 success:true,
    175.                 msg:'房间查询成功！',
    176.                 room:data.get()
    177.             })
    178.         }else{
    179.             res.status(200).json({
    180.                 success:false,
    181.                 msg:'未查询到该房间信息'
    182.             })
    183.         }
    184.     })
    185.     .catch(err =>{
    186.         res.status(200).json({
    187.             success:false,
    188.             msg:'服务器内部错误！'
    189.         })
    190.     })
    191. })
    192.  
    193. roomRouter.get('/getNotInRoom',(req,res) =>{//获取未入住房间信息
    194.     const { pageSize, offset } = req.query;
    195.     room.findAndCountAll({
    196.         limit:pageSize,
    197.         offset:offset,
    198.         where:{
    199.             roomStatus:{
    200.                 [Op.eq]:'未入住'
    201.             }
    202.         }
    203.     })
    204.     .then(data =>{
    205.         res.status(200).json({
    206.             success:true,
    207.             msg:'未入住房间查询成功!',
    208.             roomList:data.rows.map(item =>{
    209.                 return item.get()
    210.             }),
    211.             count:data.count
    212.         })
    213.     })
    214.     .catch(err =>{
    215.         res.status(200).json({
    216.             success:false,
    217.             msg:'服务器内部错误！'
    218.         })
    219.     })
    220. })
    221.  
    222. roomRouter.get('/getInRoom',(req,res) =>{//查询已入住房间信息
    223.     const { pageSize, offset } = req.query;
    224.     room.findAndCountAll({
    225.         limit:pageSize,
    226.         offset:offset,
    227.         where:{
    228.             roomStatus:{
    229.                 [Op.eq]:'已入住'
    230.             }
    231.         }
    232.     })
    233.     .then(data =>{
    234.         res.status(200).json({
    235.             success:true,
    236.             msg:'已入住房间查询成功！',
    237.             roomList:data.rows.map(item =>{
    238.                 return item.get()
    239.             }),
    240.             count:data.count
    241.         })
    242.     })
    243.     .catch(err =>{
    244.         res.status(200).json({
    245.             success:false,
    246.             msg:'服务器内部错误！'
    247.         })
    248.     })
    249. })
    250.  
    251. roomRouter.get('/getAllRoomPrice',(req,res) =>{//查询所有的房间以及价格
    252.     const { pageSize, offset } = req.query;
    253.     room.findAndCountAll({
    254.         limit:pageSize,
    255.         offset:offset,
    256.         include:[{
    257.             model:roomType,
    258.             foreignKey:'type',
    259.             attributes:['price','url']
    260.         }]
    261.     })
    262.     .then(data =>{
    263.         res.status(200).json({
    264.             success:true,
    265.             msg:'房间信息查询成功!',
    266.             roomList:data.rows.map(item =>{
    267.                 return item.get()
    268.             }),
    269.             count:data.count
    270.         })
    271.     })
    272.     .catch(err =>{
    273.         res.status(200).json({
    274.             success:false,
    275.             msg:'服务器内部错误！'
    276.         })
    277.     })
    278. })
    279.  
    280. roomRouter.get('/getAllNotINRoomPrice',(req,res) =>{//获取所有未入住的房间信息
    281.     const { pageSize, offset } = req.query;
    282.     room.findAndCountAll({
    283.         limit:pageSize,
    284.         offset:offset,
    285.         where:{
    286.             roomStatus:{
    287.                 [Op.eq]:'未入住'
    288.             }
    289.         },
    290.         include:[{
    291.             model:roomType,
    292.             foreignKey:'type',
    293.             attributes:['price','url']
    294.         }]
    295.     })
    296.     .then(data =>{
    297.        res.status(200).json({
    298.            success:true,
    299.            msg:'房间信息查询成功！',
    300.            roomList:data.rows.map(item =>{
    301.                return item.get()
    302.            }),
    303.            count:data.count
    304.        })
    305.     })
    306. })
    307.  
    308. roomRouter.get('/getAllINRoomPrice',(req,res) =>{//获取所有已入住的房间信息
    309.     const { pageSize, offset } = req.query;
    310.     room.findAndCountAll({
    311.         limit:pageSize,
    312.         offset:offset,
    313.         where:{
    314.             roomStatus:{
    315.                 [Op.eq]:'已入住'
    316.             }
    317.         },
    318.         include:[{
    319.             model:roomType,
    320.             foreignKey:'type',
    321.             attributes:['price','url']
    322.         }]
    323.     })
    324.     .then(data =>{
    325.        res.status(200).json({
    326.            success:true,
    327.            msg:'房间信息查询成功！',
    328.            roomList:data.rows.map(item =>{
    329.                return item.get()
    330.            }),
    331.            count:data.count
    332.        })
    333.     })
    334. })
    335.  
    336. roomRouter.get('/getAllRoomTypePrice',(req,res) =>{
    337.     const { pageSize, offset, type } = req.query;
    338.     room.findAndCountAll({
    339.         where:{
    340.            type:{
    341.                [Op.eq]:type
    342.            }
    343.         },
    344.         include:[{
    345.             model:roomType,
    346.             foreignKey:'type',
    347.             attributes:['price','url']
    348.         }]
    349.     })
    350.     .then(data =>{
    351.         res.status(200).json({
    352.             success:true,
    353.             msg:'房型查询成功！',
    354.             roomList:data.rows.map(item =>{
    355.                 return item.get()
    356.             }),
    357.             count:data.count
    358.         })
    359.     })
    360.     .catch(err =>{
    361.         res.status(200).json({
    362.             success:false,
    363.             msg:'服务器出错！'
    364.         })
    365.     })
    366. })
    367.  
    368. roomRouter.get('/getAllStatusRoom',(req,res) =>{//获取所有该状态的房间信息
    369.     const { pageSize, offset, roomStatus } = req.query;
    370.     room.findAndCountAll({
    371.         limit:pageSize,
    372.         offset:offset,
    373.         where:{
    374.             roomStatus:{
    375.                 [Op.eq]:roomStatus
    376.             }
    377.         },
    378.         include:[{
    379.             model:roomType,
    380.             foreignKey:'type',
    381.             attributes:['price','url']
    382.         }]
    383.     })
    384.     .then(data =>{
    385.        res.status(200).json({
    386.            success:true,
    387.            msg:'房间信息查询成功！',
    388.            roomList:data.rows.map(item =>{
    389.                return item.get()
    390.            }),
    391.            count:data.count
    392.        })
    393.     })
    394. })
    395.  
    396.  
    397. module.exports = roomRouter

    五，项目总结

  • 相关阅读:
    [ansible]playbook结合项目解释执行步骤
    Matlab 中@ 的用法
    【PTHREAD】线程状态
    Centos7环境下安装MySQL8详细教程
    微信小程序自定义组件及投票管理与个人中心界面搭建
    狂神说Es
    亚马逊的卫星发射升空，它和“星链”在讲什么故事?
    创建ffmpeg vs2019工程
    服务于金融新核心系统 星辰天合与中电金信完成产品兼容认证
    计算机毕业设计Python+djang的疫情数据可视化分析系统(源码+系统+mysql数据库+Lw文档）
  • 原文地址：https://blog.csdn.net/BS009/article/details/127611649