• 基于VUE的酒店管理系统的设计与实现

    作者主页：编程指南针

    作者简介：Java领域优质创作者、CSDN博客专家 、掘金特邀作者、多年架构师设计经验、腾讯课堂常驻讲师

    主要内容：Java项目、毕业设计、简历模板、学习资料、面试题库、技术互助

    文末获取源码 

    一，项目简介

    随着社会和科技的发展，现代化是当今社会的一个重要改革，而这其中酒店行业的出现和发展已经具有很长的历史了,发展到现在酒店的管理模式也较为完整了,但随着人口的增长、酒店多元化的出现，酒店行业在业务上的发展也到了一定的瓶颈期。在如此庞大信息量的情况下，如果像以前所有的事情都由人工操作显然是及其困难，并且极易出错的。要想提高劳动生产力，进而促进酒店的经济效益，必须借助计算机来进行改革。由此酒店管理系统就应运而生。

    本系统主要是为了解决人手不足，管理方便而设计的，使用VUE作为网页前端开发语言和SpringBoot及Mybatis作为后台服务器开发语言，使用MySQL数据库作为酒店管理系统的数据库，前端开发工具为Hbuilder、后台用IDEA，模式采用前后端分离模式进行开发。主要实现了添加员工功能、登记入住功能、退房功能、房间管理功能、系统通知、好友聊天、登录功能等功能。基本上满足了旅客到店里来入住以及酒店日常管理的功能，极大的方便了酒店的管理，减少了劳动力与出错率。

    在这个时代，社会随着科技日新月异改变，电脑软件的使用不仅在群众中的普及率越来越高，在日常的生活中人们使用电脑的情况也越来越多，因此电脑软件在人们工作和生活中起到了非常重要的作用。而随着国家对旅游业的发展和支持，酒店行业激烈的竞争着客户的资源，为此酒店行业争取客源、提高酒店的满员率、制定正确的营销策略已经成为酒店的一项重要任务，而借助于当前蓬勃发展的系统工具来拓展销售能力，创造客观的经济效益已经成为许多酒店的首选。再加上国际、国内名优企业的扩展力度的加大，宾馆、酒店业集团化的步伐加快，预示着传统的宾馆、酒店正逐步步向信息化管理，但是国内中小型酒店占着绝大多数的情况，宾馆由于资金少、人员缺乏等多方面的原因不易使用酒店管理类软件，所以依靠原始的手工记录管理会出现效率低、容易出错等问题，而且大型的酒店管理系统对于中小型酒店来说，有很多功能根本用不上。所以结合酒店前台管理的需要进行扩展性而开发的一套酒店管理系统。本系统是一套适用于中小型酒店使用的优秀系统。

    主要针对的是中小型酒店的设计的，基本符合他们所要用到的功能。目前，本设计应解决的主要的功能有三个:

    1. 客户的管理

    要对客户进行有效的管理，减少入住、退房、个人信息等的出错，为酒店带来不必要的麻烦。

    1. 酒店员工的管理

    对员工的管理，是酒店管理的一个重要的部分，只有管理好员工，酒店才能正常的运作。

    1. 权限的管理

    每个酒店的都有不同的职位，老板，前台，清洁工等，要对他们进行权限的分配，不然酒店的管理会出现混乱。

    本系统主要由以下几个功能模块组成;

    登录功能：员工可以通过登陆界面的进入，系统的主界面。

    系统通知功能：管理员可以通过系统发送通知功能给员工发送通知。

    登记入住功能：在有客户想要住店时，员工可以纪录客户的信息。

    客户管理功能：可以查看已入住的客户，并且进行退房和修改信息以及查询的操作。

    员工管理功能：可以查看员工的信息，修改员工的信息。

    权限管理功能：可以管理员工的权限，防止任意操作。

    房间管理功能：可以设定酒店房间的类型和价格。

    员工聊天功能：此模块可以供员工之间的信息沟通，更方便工作的交流。

    系统的架构如图4.1所示，操作大致的流程如图4.2所示，操作员以及相应功能如图4.3所示。

    图4.1系统架构图

    图4.2操作流程图

    图4.3管理用例图


     

    二，环境介绍

    语言环境：Java:  jdk1.8

    数据库：Mysql: mysql5.7

    应用服务器：Tomcat:  tomcat8.5.31

    开发工具：IDEA或eclipse

    后台开发技术：Springboot+Mybatis

    前台开技术：VUE+ElementUI

    三，系统展示

    6.1 系统登陆界面

    要登陆酒店管理系统必须通过系统的登陆平台，输入正确的用户名和密码，通过login()接口将数据通过axios传输到后台，后台通过loginControl调取数据表hr的信息，经过验证后才可以进入系统的主页面，如果输入的信息有误，系统会出现相应的错误提示。如输入用户名admin，密码123，点击登录，就可以进入主界面，并得到登录成功的提示。登录界面如图6.1所示，成功提示如图6.2所示。

    图6.1登录界面图

    图6.2登录成功图

    6.2 系统主界面

    通过登录后，界面会进入到主界面，此时主界面会根据用户的权限显示相应的功能。这里以系统管理员为例，管理员进入主界面后可以看到员工管理客户管理系统管以及左上角的系统通知等功能，如图6.3所示。而普通员工只能看到客户管理的业务，如图6.4所示。

    图6.3管理员界面图

    图6.4普通员工图

    6.3 系统通知

    点击右上角的铃铛图标，进入系统通知的界面，员工可以看到系统管理员发送的信息，但是只有系统管理员可以发送系统通知，其他人只能查看通知，未查看的通知会标记为红色。已读时红色标记会消失，而在通知列表里面还可以看到以往所有的通知包括标题，通知时间。系统通知界面如图6.5所示。

    图6.5 系统通知图

    6.4 聊天功能

    点击好友聊天，进入聊天界面，可以实现与好友聊天的功能，例如选择李白聊天，在输入框输入信息点击发送就可以发送聊天信息，这时就会在聊天信息界面显示聊天的信息，但是当你关闭聊天信息界面时，所有的聊天信息将会清除。聊天功能界面如图6.6所示。

    图6.6聊天功能图

    6.5 添加员工

    点击员工资料，再点击基本资料，可以看到酒店所有员工的基本信息，如图6.7所示，再点击右边的添加员工按钮可以进入添加员工的界面，输入完整有效的信息如员工姓名、电话、员工卡号、身份证等信息，然后点击确定按钮，即可添加成功，如图6.8所示。同时会显示在列表中。如果不想添加点击取消按钮即可返回列表界面。

    图6.7员工界面图

    图6.8添加功能图

    6.6 员工查询

    在查询输入框中，输入员工的姓名，点击查询即可查询到员工的信息，如输入“陈静”，点击查询，在列表中就可以显示出有陈静二字的员工信息，如图6.9所示。

    图6.9员工查询图

    6.7 修改员工信息

    点击员工列表右侧修改信息按钮，在弹出的修改界面，选者修改的信息，修改完成后，点击确认按钮，系统会提示修改成功，就可以在员工列表上看到相应员工信息已经修改，如图6.10所示。

    图6.10员工修改图

    6.8 登记入住

    点击客户管理，进入界面后点击登记入住按钮，在弹出的登记界面填写正确的客户信息如姓名、电话、身份证、选择房间等信息，点击确认，即可登记客户的入住信息如图6.11所示。同时在客户列表中可以看到登记的信息。

    图6.11登记入住图

    6.9 退房功能

        在有客户想退房时，点击客户列表右侧的退房按钮，就可以给客户进行退房的程序，退房界面如图6.12所示。

    图6.12 退房功能图

    6.10 添加房间

    点击添加房间按钮，进入房间管理界面，可进行添加房间的操作，输入房号，房型，定价，备注再点击保存按钮即可添加房间，如果不添加则点击取消。添加房间界面如图6.13所示。

    图6.13 添加房间图

    6.11 权限分配

    点击权限分配菜单进入权限分配界面，可以对相应职位给予相应的酒店管理权限，操作员进入后，只会看到相应的权限菜单，如李白给予的权限为员工管理和客户管理，这进入主界面后只能看到两个菜单，如图6.13所示。

    图6.14 权限分配图

    6.12 权限管理

    点击系统管理菜单，进入操作员管理界面，可看到部分操作员的信息如图6.15所示，可对操作员进行登录权限的修改，禁止或启动操作员的权限，一旦禁止后，该操作员将不能登陆系统。

    图6.15 权限管理图


     

    四，核心代码展示

    1. package com.ischoolbar.programmer.controller.admin;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. import org.apache.commons.lang.StringUtils;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Controller;
    9. import org.springframework.web.bind.annotation.RequestMapping;
    10. import org.springframework.web.bind.annotation.RequestMethod;
    11. import org.springframework.web.bind.annotation.RequestParam;
    12. import org.springframework.web.bind.annotation.ResponseBody;
    13. import org.springframework.web.servlet.ModelAndView;
    14.  
    15. import com.ischoolbar.programmer.entity.Account;
    16. import com.ischoolbar.programmer.page.admin.Page;
    17. import com.ischoolbar.programmer.service.AccountService;
    18.  
    19. /**
    20.  * 客户管理后台控制器
    21.  * @author Administrator
    22.  *
    23.  */
    24. @RequestMapping("/admin/account")
    25. @Controller
    26. public class AccountController {
    27. 	
    28. 	@Autowired
    29. 	private AccountService accountService;
    30. 	
    31. 	
    32. 	/**
    33. 	 * 客户管理列表页面
    34. 	 * @param model
    35. 	 * @return
    36. 	 */
    37. 	@RequestMapping(value="/list",method=RequestMethod.GET)
    38. 	public ModelAndView list(ModelAndView model){
    39. 		model.setViewName("account/list");
    40. 		return model;
    41. 	}
    42. 	
    43. 	/**
    44. 	 * 客户信息添加操作
    45. 	 * @param account
    46. 	 * @return
    47. 	 */
    48. 	@RequestMapping(value="/add",method=RequestMethod.POST)
    49. 	@ResponseBody
    50. 	public Map add(Account account){
    51. 		Map ret = new HashMap();
    52. 		if(account == null){
    53. 			ret.put("type", "error");
    54. 			ret.put("msg", "请填写正确的客户信息!");
    55. 			return ret;
    56. 		}
    57. 		if(StringUtils.isEmpty(account.getName())){
    58. 			ret.put("type", "error");
    59. 			ret.put("msg", "客户名称不能为空!");
    60. 			return ret;
    61. 		}
    62. 		if(StringUtils.isEmpty(account.getPassword())){
    63. 			ret.put("type", "error");
    64. 			ret.put("msg", "客户密码不能为空!");
    65. 			return ret;
    66. 		}
    67. 		if(isExist(account.getName(), 0l)){
    68. 			ret.put("type", "error");
    69. 			ret.put("msg", "该用户名已经存在!");
    70. 			return ret;
    71. 		}
    72. 		if(accountService.add(account) <= 0){
    73. 			ret.put("type", "error");
    74. 			ret.put("msg", "添加失败，请联系管理员!");
    75. 			return ret;
    76. 		}
    77. 		ret.put("type", "success");
    78. 		ret.put("msg", "添加成功!");
    79. 		return ret;
    80. 	}
    81. 	
    82. 	/**
    83. 	 * 客户信息编辑操作
    84. 	 * @param account
    85. 	 * @return
    86. 	 */
    87. 	@RequestMapping(value="/edit",method=RequestMethod.POST)
    88. 	@ResponseBody
    89. 	public Map edit(Account account){
    90. 		Map ret = new HashMap();
    91. 		if(account == null){
    92. 			ret.put("type", "error");
    93. 			ret.put("msg", "请填写正确的客户信息!");
    94. 			return ret;
    95. 		}
    96. 		if(StringUtils.isEmpty(account.getName())){
    97. 			ret.put("type", "error");
    98. 			ret.put("msg", "客户名称不能为空!");
    99. 			return ret;
    100. 		}
    101. 		if(StringUtils.isEmpty(account.getPassword())){
    102. 			ret.put("type", "error");
    103. 			ret.put("msg", "客户密码不能为空!");
    104. 			return ret;
    105. 		}
    106. 		if(isExist(account.getName(), account.getId())){
    107. 			ret.put("type", "error");
    108. 			ret.put("msg", "该用户名已经存在!");
    109. 			return ret;
    110. 		}
    111. 		if(accountService.edit(account) <= 0){
    112. 			ret.put("type", "error");
    113. 			ret.put("msg", "添加失败，请联系管理员!");
    114. 			return ret;
    115. 		}
    116. 		ret.put("type", "success");
    117. 		ret.put("msg", "修改成功!");
    118. 		return ret;
    119. 	}
    120. 	
    121. 	/**
    122. 	 * 分页查询客户信息
    123. 	 * @param name
    124. 	 * @param page
    125. 	 * @return
    126. 	 */
    127. 	@RequestMapping(value="/list",method=RequestMethod.POST)
    128. 	@ResponseBody
    129. 	public Map list(
    130. 			@RequestParam(name="name",defaultValue="") String name,
    131. 			@RequestParam(name="realName",defaultValue="") String realName,
    132. 			@RequestParam(name="idCard",defaultValue="") String idCard,
    133. 			@RequestParam(name="mobile",defaultValue="") String mobile,
    134. 			@RequestParam(name="status",required=false) Integer status,
    135. 			Page page
    136. 			){
    137. 		Map ret = new HashMap();
    138. 		Map queryMap = new HashMap();
    139. 		queryMap.put("name", name);
    140. 		queryMap.put("status", status);
    141. 		queryMap.put("realName", realName);
    142. 		queryMap.put("idCard", idCard);
    143. 		queryMap.put("mobile", mobile);
    144. 		queryMap.put("offset", page.getOffset());
    145. 		queryMap.put("pageSize", page.getRows());
    146. 		ret.put("rows", accountService.findList(queryMap));
    147. 		ret.put("total", accountService.getTotal(queryMap));
    148. 		return ret;
    149. 	}
    150. 	
    151. 	/**
    152. 	 * 客户信息删除操作
    153. 	 * @param id
    154. 	 * @return
    155. 	 */
    156. 	@RequestMapping(value="/delete",method=RequestMethod.POST)
    157. 	@ResponseBody
    158. 	public Map delete(Long id){
    159. 		Map ret = new HashMap();
    160. 		if(id == null){
    161. 			ret.put("type", "error");
    162. 			ret.put("msg", "请选择要删除的信息!");
    163. 			return ret;
    164. 		}
    165. 		try {
    166. 			if(accountService.delete(id) <= 0){
    167. 				ret.put("type", "error");
    168. 				ret.put("msg", "删除失败，请联系管理员!");
    169. 				return ret;
    170. 			}
    171. 		} catch (Exception e) {
    172. 			// TODO: handle exception
    173. 			ret.put("type", "error");
    174. 			ret.put("msg", "该客户下存在订单信息，请先删除该客户下的所有订单信息!");
    175. 			return ret;
    176. 		}
    177. 		ret.put("type", "success");
    178. 		ret.put("msg", "删除成功!");
    179. 		return ret;
    180. 	}
    181. 	
    182. 	/**
    183. 	 * 判断用户名是否存在
    184. 	 * @param name
    185. 	 * @param id
    186. 	 * @return
    187. 	 */
    188. 	private boolean isExist(String name,Long id){
    189. 		Account findByName = accountService.findByName(name);
    190. 		if(findByName == null)return false;
    191. 		if(findByName.getId().longValue() == id.longValue())return false;
    192. 		return true;
    193. 	}
    194. }
    1. package com.ischoolbar.programmer.controller.admin;
    2.  
    3. import java.util.Date;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6.  
    7. import org.apache.commons.lang.StringUtils;
    8. import org.springframework.beans.factory.annotation.Autowired;
    9. import org.springframework.stereotype.Controller;
    10. import org.springframework.web.bind.annotation.RequestMapping;
    11. import org.springframework.web.bind.annotation.RequestMethod;
    12. import org.springframework.web.bind.annotation.RequestParam;
    13. import org.springframework.web.bind.annotation.ResponseBody;
    14. import org.springframework.web.servlet.ModelAndView;
    15.  
    16. import com.ischoolbar.programmer.entity.BookOrder;
    17. import com.ischoolbar.programmer.entity.RoomType;
    18. import com.ischoolbar.programmer.page.admin.Page;
    19. import com.ischoolbar.programmer.service.AccountService;
    20. import com.ischoolbar.programmer.service.BookOrderService;
    21. import com.ischoolbar.programmer.service.RoomTypeService;
    22.  
    23. /**
    24.  * 预定订单管理后台控制器
    25.  * @author Administrator
    26.  *
    27.  */
    28. @RequestMapping("/admin/book_order")
    29. @Controller
    30. public class BookOrderController {
    31. 	
    32. 	@Autowired
    33. 	private AccountService accountService;
    34. 	@Autowired
    35. 	private RoomTypeService roomTypeService;
    36. 	@Autowired
    37. 	private BookOrderService bookOrderService;
    38. 	
    39. 	
    40. 	/**
    41. 	 * 预定订单管理列表页面
    42. 	 * @param model
    43. 	 * @return
    44. 	 */
    45. 	@RequestMapping(value="/list",method=RequestMethod.GET)
    46. 	public ModelAndView list(ModelAndView model){
    47. 		model.addObject("roomTypeList", roomTypeService.findAll());
    48. 		model.addObject("accountList", accountService.findAll());
    49. 		model.setViewName("book_order/list");
    50. 		return model;
    51. 	}
    52. 	
    53. 	/**
    54. 	 * 预定订单信息添加操作
    55. 	 * @param bookOrder
    56. 	 * @return
    57. 	 */
    58. 	@RequestMapping(value="/add",method=RequestMethod.POST)
    59. 	@ResponseBody
    60. 	public Map add(BookOrder bookOrder){
    61. 		Map ret = new HashMap();
    62. 		if(bookOrder == null){
    63. 			ret.put("type", "error");
    64. 			ret.put("msg", "请填写正确的预定订单信息!");
    65. 			return ret;
    66. 		}
    67. 		if(bookOrder.getAccountId() == null){
    68. 			ret.put("type", "error");
    69. 			ret.put("msg", "客户不能为空!");
    70. 			return ret;
    71. 		}
    72. 		if(bookOrder.getRoomTypeId() == null){
    73. 			ret.put("type", "error");
    74. 			ret.put("msg", "房型不能为空!");
    75. 			return ret;
    76. 		}
    77. 		if(StringUtils.isEmpty(bookOrder.getName())){
    78. 			ret.put("type", "error");
    79. 			ret.put("msg", "预定订单联系人名称不能为空!");
    80. 			return ret;
    81. 		}
    82. 		if(StringUtils.isEmpty(bookOrder.getMobile())){
    83. 			ret.put("type", "error");
    84. 			ret.put("msg", "预定订单联系人手机号不能为空!");
    85. 			return ret;
    86. 		}
    87. 		if(StringUtils.isEmpty(bookOrder.getIdCard())){
    88. 			ret.put("type", "error");
    89. 			ret.put("msg", "联系人身份证号不能为空!");
    90. 			return ret;
    91. 		}
    92. 		if(StringUtils.isEmpty(bookOrder.getArriveDate())){
    93. 			ret.put("type", "error");
    94. 			ret.put("msg", "到达时间不能为空!");
    95. 			return ret;
    96. 		}
    97. 		if(StringUtils.isEmpty(bookOrder.getLeaveDate())){
    98. 			ret.put("type", "error");
    99. 			ret.put("msg", "离店时间不能为空!");
    100. 			return ret;
    101. 		}
    102. 		bookOrder.setCreateTime(new Date());
    103. 		if(bookOrderService.add(bookOrder) <= 0){
    104. 			ret.put("type", "error");
    105. 			ret.put("msg", "添加失败，请联系管理员!");
    106. 			return ret;
    107. 		}
    108. 		RoomType roomType = roomTypeService.find(bookOrder.getRoomTypeId());
    109. 		//预定成功后去修改该房型的预定数
    110. 		if(roomType != null){
    111. 			roomType.setBookNum(roomType.getBookNum() + 1);
    112. 			roomType.setAvilableNum(roomType.getAvilableNum() - 1);
    113. 			roomTypeService.updateNum(roomType);
    114. 			//如果可用的房间数为0，则设置该房型状态已满
    115. 			if(roomType.getAvilableNum() == 0){
    116. 				roomType.setStatus(0);
    117. 				roomTypeService.edit(roomType);
    118. 			}
    119. 		}
    120. 		ret.put("type", "success");
    121. 		ret.put("msg", "添加成功!");
    122. 		return ret;
    123. 	}
    124. 	
    125. 	/**
    126. 	 * 预定订单信息编辑操作
    127. 	 * @param account
    128. 	 * @return
    129. 	 */
    130. 	@RequestMapping(value="/edit",method=RequestMethod.POST)
    131. 	@ResponseBody
    132. 	public Map edit(BookOrder bookOrder){
    133. 		Map ret = new HashMap();
    134. 		if(bookOrder == null){
    135. 			ret.put("type", "error");
    136. 			ret.put("msg", "请填写正确的预定订单信息!");
    137. 			return ret;
    138. 		}
    139. 		if(bookOrder.getAccountId() == null){
    140. 			ret.put("type", "error");
    141. 			ret.put("msg", "客户不能为空!");
    142. 			return ret;
    143. 		}
    144. 		if(bookOrder.getRoomTypeId() == null){
    145. 			ret.put("type", "error");
    146. 			ret.put("msg", "房型不能为空!");
    147. 			return ret;
    148. 		}
    149. 		if(StringUtils.isEmpty(bookOrder.getName())){
    150. 			ret.put("type", "error");
    151. 			ret.put("msg", "预定订单联系人名称不能为空!");
    152. 			return ret;
    153. 		}
    154. 		if(StringUtils.isEmpty(bookOrder.getMobile())){
    155. 			ret.put("type", "error");
    156. 			ret.put("msg", "预定订单联系人手机号不能为空!");
    157. 			return ret;
    158. 		}
    159. 		if(StringUtils.isEmpty(bookOrder.getIdCard())){
    160. 			ret.put("type", "error");
    161. 			ret.put("msg", "联系人身份证号不能为空!");
    162. 			return ret;
    163. 		}
    164. 		if(StringUtils.isEmpty(bookOrder.getArriveDate())){
    165. 			ret.put("type", "error");
    166. 			ret.put("msg", "到达时间不能为空!");
    167. 			return ret;
    168. 		}
    169. 		if(StringUtils.isEmpty(bookOrder.getLeaveDate())){
    170. 			ret.put("type", "error");
    171. 			ret.put("msg", "离店时间不能为空!");
    172. 			return ret;
    173. 		}
    174. 		BookOrder existBookOrder = bookOrderService.find(bookOrder.getId());
    175. 		if(existBookOrder == null){
    176. 			ret.put("type", "error");
    177. 			ret.put("msg", "请选择正确的数据进行编辑!");
    178. 			return ret;
    179. 		}
    180. 		if(bookOrderService.edit(bookOrder) <= 0){
    181. 			ret.put("type", "error");
    182. 			ret.put("msg", "编辑失败，请联系管理员!");
    183. 			return ret;
    184. 		}
    185. 		//判断房型是否发生变化
    186. 		if(existBookOrder.getRoomTypeId().longValue() != bookOrder.getRoomTypeId().longValue()){
    187. 			//房型发生了变化
    188. 			//首先恢复原来房型的预定数及可用数
    189. 			RoomType oldRoomType = roomTypeService.find(existBookOrder.getRoomTypeId());
    190. 			oldRoomType.setAvilableNum(oldRoomType.getAvilableNum() + 1);
    191. 			oldRoomType.setBookNum(oldRoomType.getBookNum() - 1);
    192. 			roomTypeService.updateNum(oldRoomType);
    193. 			if(oldRoomType.getStatus() == 0){
    194. 				//旧的房间原来是满房，现在不满房的话，恢复状态
    195. 				if(oldRoomType.getAvilableNum() > 0){
    196. 					//设置成状态可用
    197. 					oldRoomType.setStatus(1);
    198. 					roomTypeService.edit(oldRoomType);
    199. 				}
    200. 			}
    201. 			//修改新的房型的可用数和预定数
    202. 			RoomType newRoomType = roomTypeService.find(bookOrder.getRoomTypeId());
    203. 			newRoomType.setAvilableNum(newRoomType.getAvilableNum() - 1);
    204. 			newRoomType.setBookNum(newRoomType.getBookNum() + 1);
    205. 			roomTypeService.updateNum(newRoomType);
    206. 			if(newRoomType.getAvilableNum() <= 0){
    207. 				//没有可用房间数
    208. 				newRoomType.setStatus(0);//设置成满房
    209. 				roomTypeService.edit(newRoomType);
    210. 			}
    211. 		}
    212. 		ret.put("type", "success");
    213. 		ret.put("msg", "修改成功!");
    214. 		return ret;
    215. 	}
    216. 	
    217. 	/**
    218. 	 * 分页查询预定订单信息
    219. 	 * @param name
    220. 	 * @param page
    221. 	 * @return
    222. 	 */
    223. 	@RequestMapping(value="/list",method=RequestMethod.POST)
    224. 	@ResponseBody
    225. 	public Map list(
    226. 			@RequestParam(name="name",defaultValue="") String name,
    227. 			@RequestParam(name="accountId",defaultValue="") Long accountId,
    228. 			@RequestParam(name="roomTypeId",defaultValue="") Long roomTypeId,
    229. 			@RequestParam(name="idCard",defaultValue="") String idCard,
    230. 			@RequestParam(name="mobile",defaultValue="") String mobile,
    231. 			@RequestParam(name="status",required=false) Integer status,
    232. 			Page page
    233. 			){
    234. 		Map ret = new HashMap();
    235. 		Map queryMap = new HashMap();
    236. 		queryMap.put("name", name);
    237. 		queryMap.put("status", status);
    238. 		queryMap.put("accountId", accountId);
    239. 		queryMap.put("roomTypeId", roomTypeId);
    240. 		queryMap.put("idCard", idCard);
    241. 		queryMap.put("mobile", mobile);
    242. 		queryMap.put("offset", page.getOffset());
    243. 		queryMap.put("pageSize", page.getRows());
    244. 		ret.put("rows", bookOrderService.findList(queryMap));
    245. 		ret.put("total", bookOrderService.getTotal(queryMap));
    246. 		return ret;
    247. 	}
    248. 	
    249. 	
    250. }
    1. package com.ischoolbar.programmer.controller.admin;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Date;
    5. import java.util.HashMap;
    6. import java.util.List;
    7. import java.util.Map;
    8.  
    9. import org.apache.commons.lang.StringUtils;
    10. import org.springframework.beans.factory.annotation.Autowired;
    11. import org.springframework.stereotype.Controller;
    12. import org.springframework.web.bind.annotation.RequestMapping;
    13. import org.springframework.web.bind.annotation.RequestMethod;
    14. import org.springframework.web.bind.annotation.RequestParam;
    15. import org.springframework.web.bind.annotation.ResponseBody;
    16. import org.springframework.web.servlet.ModelAndView;
    17.  
    18. import com.ischoolbar.programmer.entity.BookOrder;
    19. import com.ischoolbar.programmer.entity.RoomType;
    20. import com.ischoolbar.programmer.entity.admin.Checkin;
    21. import com.ischoolbar.programmer.entity.admin.Room;
    22. import com.ischoolbar.programmer.page.admin.Page;
    23. import com.ischoolbar.programmer.service.BookOrderService;
    24. import com.ischoolbar.programmer.service.RoomTypeService;
    25. import com.ischoolbar.programmer.service.admin.CheckinService;
    26. import com.ischoolbar.programmer.service.admin.RoomService;
    27.  
    28. /**
    29.  * 入住管理后台控制器
    30.  * @author Administrator
    31.  *
    32.  */
    33. @RequestMapping("/admin/checkin")
    34. @Controller
    35. public class CheckinController {
    36. 	
    37. 	@Autowired
    38. 	private RoomService roomService;
    39. 	@Autowired
    40. 	private RoomTypeService roomTypeService;
    41. 	@Autowired
    42. 	private BookOrderService bookOrderService;
    43. 	@Autowired
    44. 	private CheckinService checkinService;
    45. 	
    46. 	/**
    47. 	 * 入住管理列表页面
    48. 	 * @param model
    49. 	 * @return
    50. 	 */
    51. 	@RequestMapping(value="/list",method=RequestMethod.GET)
    52. 	public ModelAndView list(ModelAndView model){
    53. 		model.addObject("roomTypeList", roomTypeService.findAll());
    54. 		model.addObject("roomList", roomService.findAll());
    55. 		model.setViewName("checkin/list");
    56. 		return model;
    57. 	}
    58. 	
    59. 	/**
    60. 	 * 入住信息添加操作
    61. 	 * @param checkin
    62. 	 * @return
    63. 	 */
    64. 	@RequestMapping(value="/add",method=RequestMethod.POST)
    65. 	@ResponseBody
    66. 	public Map add(Checkin checkin,
    67. 			@RequestParam(name="bookOrderId",required=false) Long bookOrderId
    68. 			){
    69. 		Map ret = new HashMap();
    70. 		if(checkin == null){
    71. 			ret.put("type", "error");
    72. 			ret.put("msg", "请填写正确的入住信息!");
    73. 			return ret;
    74. 		}
    75. 		if(checkin.getRoomId() == null){
    76. 			ret.put("type", "error");
    77. 			ret.put("msg", "房间不能为空!");
    78. 			return ret;
    79. 		}
    80. 		if(checkin.getRoomTypeId() == null){
    81. 			ret.put("type", "error");
    82. 			ret.put("msg", "房型不能为空!");
    83. 			return ret;
    84. 		}
    85. 		if(StringUtils.isEmpty(checkin.getName())){
    86. 			ret.put("type", "error");
    87. 			ret.put("msg", "入住联系人名称不能为空!");
    88. 			return ret;
    89. 		}
    90. 		if(StringUtils.isEmpty(checkin.getMobile())){
    91. 			ret.put("type", "error");
    92. 			ret.put("msg", "入住联系人手机号不能为空!");
    93. 			return ret;
    94. 		}
    95. 		if(StringUtils.isEmpty(checkin.getIdCard())){
    96. 			ret.put("type", "error");
    97. 			ret.put("msg", "联系人身份证号不能为空!");
    98. 			return ret;
    99. 		}
    100. 		if(StringUtils.isEmpty(checkin.getArriveDate())){
    101. 			ret.put("type", "error");
    102. 			ret.put("msg", "到达时间不能为空!");
    103. 			return ret;
    104. 		}
    105. 		if(StringUtils.isEmpty(checkin.getLeaveDate())){
    106. 			ret.put("type", "error");
    107. 			ret.put("msg", "离店时间不能为空!");
    108. 			return ret;
    109. 		}
    110. 		checkin.setCreateTime(new Date());
    111. 		if(checkinService.add(checkin) <= 0){
    112. 			ret.put("type", "error");
    113. 			ret.put("msg", "添加失败，请联系管理员!");
    114. 			return ret;
    115. 		}
    116. 		RoomType roomType = roomTypeService.find(checkin.getRoomTypeId());
    117. 		
    118. 		if(bookOrderId != null){
    119. 			//从预定来的入住单(入住既可以是直接入住也可以是已经预定的人来入住)
    120. 			BookOrder bookOrder = bookOrderService.find(bookOrderId);
    121. 			bookOrder.setStatus(1);
    122. 			bookOrderService.edit(bookOrder);
    123. 			//roomType.setBookNum(roomType.getBookNum() - 1);//预定数减1
    124. 		}else{
    125. 			roomType.setAvilableNum(roomType.getAvilableNum() - 1);
    126. 		}
    127. 		//入住成功后去修改该房型的预定数
    128. 		if(roomType != null){
    129. 			roomType.setLivedNum(roomType.getLivedNum() + 1);//入住数加1
    130. 			roomTypeService.updateNum(roomType);
    131. 			//如果可用的房间数为0，则设置该房型状态已满
    132. 			if(roomType.getAvilableNum() == 0){
    133. 				roomType.setStatus(0);
    134. 				roomTypeService.edit(roomType);
    135. 			}
    136. 		}
    137. 		Room room = roomService.find(checkin.getRoomId());
    138. 		if(room != null){
    139. 			//要把房间状态设置为已入住
    140. 			room.setStatus(1);
    141. 			roomService.edit(room);
    142. 		}
    143. 		ret.put("type", "success");
    144. 		ret.put("msg", "添加成功!");
    145. 		return ret;
    146. 	}
    147. 	
    148. 	/**
    149. 	 * 入住信息编辑操作
    150. 	 * @param account
    151. 	 * @return
    152. 	 */
    153. 	@RequestMapping(value="/edit",method=RequestMethod.POST)
    154. 	@ResponseBody
    155. 	public Map edit(Checkin checkin,
    156. 			@RequestParam(name="bookOrderId",required=false) Long bookOrderId
    157. 			){
    158. 		Map ret = new HashMap();
    159. 		if(checkin == null){
    160. 			ret.put("type", "error");
    161. 			ret.put("msg", "请填写正确的入住信息!");
    162. 			return ret;
    163. 		}
    164. 		if(checkin.getRoomId() == null){
    165. 			ret.put("type", "error");
    166. 			ret.put("msg", "房间不能为空!");
    167. 			return ret;
    168. 		}
    169. 		if(checkin.getRoomTypeId() == null){
    170. 			ret.put("type", "error");
    171. 			ret.put("msg", "房型不能为空!");
    172. 			return ret;
    173. 		}
    174. 		if(StringUtils.isEmpty(checkin.getName())){
    175. 			ret.put("type", "error");
    176. 			ret.put("msg", "入住联系人名称不能为空!");
    177. 			return ret;
    178. 		}
    179. 		if(StringUtils.isEmpty(checkin.getMobile())){
    180. 			ret.put("type", "error");
    181. 			ret.put("msg", "入住联系人手机号不能为空!");
    182. 			return ret;
    183. 		}
    184. 		if(StringUtils.isEmpty(checkin.getIdCard())){
    185. 			ret.put("type", "error");
    186. 			ret.put("msg", "联系人身份证号不能为空!");
    187. 			return ret;
    188. 		}
    189. 		if(StringUtils.isEmpty(checkin.getArriveDate())){
    190. 			ret.put("type", "error");
    191. 			ret.put("msg", "到达时间不能为空!");
    192. 			return ret;
    193. 		}
    194. 		if(StringUtils.isEmpty(checkin.getLeaveDate())){
    195. 			ret.put("type", "error");
    196. 			ret.put("msg", "离店时间不能为空!");
    197. 			return ret;
    198. 		}
    199. 		Checkin existCheckin = checkinService.find(checkin.getId());
    200. 		if(existCheckin == null){
    201. 			ret.put("type", "error");
    202. 			ret.put("msg", "请选择正确的入住信息进行编辑!");
    203. 			return ret;
    204. 		}
    205. 		if(checkinService.edit(checkin) <= 0){
    206. 			ret.put("type", "error");
    207. 			ret.put("msg", "编辑失败，请联系管理员!");
    208. 			return ret;
    209. 		}
    210. 		//编辑成功之后：1：判断房型是否发生变化，2：判断房间是否发生变化，3：判断是否是从预定订单来的信息
    211. 		//首先判断是否是从预定来的入住信息
    212. 		RoomType oldRoomType = roomTypeService.find(existCheckin.getRoomTypeId());
    213. 		RoomType newRoomType = roomTypeService.find(checkin.getRoomTypeId());
    214. 		
    215. 		//房型入住数不收预定订单的影响
    216. 		if(oldRoomType.getId().longValue() != newRoomType.getId().longValue()){
    217. 			//说明房型发生了变化，原来的房型入住数恢复，新的房型入住数增加
    218. 			oldRoomType.setLivedNum(oldRoomType.getLivedNum() - 1);
    219. 			newRoomType.setLivedNum(newRoomType.getLivedNum() + 1);
    220. 			if(bookOrderId == null){
    221. 				oldRoomType.setAvilableNum(oldRoomType.getAvilableNum() + 1);
    222. 				newRoomType.setAvilableNum(newRoomType.getAvilableNum() - 1);
    223. 			}
    224. 		}
    225. 		/**
    226. 		if(bookOrderId == null){
    227. 			//表示不是从预定订单来的，此时需判断原来的入住信息是否来源于预定
    228. 			if(existCheckin.getBookOrderId() == null){
    229. 				oldRoomType.setAvilableNum(oldRoomType.getAvilableNum() + 1);
    230. 				newRoomType.setAvilableNum(newRoomType.getAvilableNum() - 1);
    231. 			}
    232. 			if(existCheckin.getBookOrderId() != null){
    233. 				//表示原来的入住信息来源于预定，但是新的入住信息不是来源于预定,需恢复原来的预定状态
    234. 				BookOrder oldBookOrder = bookOrderService.find(existCheckin.getBookOrderId());
    235. 				oldBookOrder.setStatus(0);
    236. 				bookOrderService.edit(oldBookOrder);
    237. 				oldRoomType.setBookNum(oldRoomType.getBookNum() + 1);
    238. 			}
    239. 		}
    240. 		//表示此时的订单是来源于预定
    241. 		if(bookOrderId != null){
    242. 			//表示是从预定订单来的，此时需判断原来的入住信息是否来源于预定
    243. 			if(existCheckin.getBookOrderId() != null){
    244. 				//表示原来的入住信息来源于预定，但是新的入住信息不是来源于预定,需恢复原来的预定状态
    245. 				BookOrder oldBookOrder = bookOrderService.find(existCheckin.getBookOrderId());
    246. 				if(bookOrderId.longValue() != oldBookOrder.getId().longValue()){
    247. 					oldBookOrder.setStatus(0);
    248. 					bookOrderService.edit(oldBookOrder);
    249. 					//oldRoomType.setBookNum(oldRoomType.getBookNum() + 1);
    250. 				}
    251. 			}
    252. 			if(oldRoomType.getId().longValue() != newRoomType.getId().longValue()){
    253. 				newRoomType.setBookNum(newRoomType.getBookNum() - 1);
    254. 				
    255. 				if(existCheckin.getBookOrderId() == null){
    256. 					oldRoomType.setAvilableNum(oldRoomType.getAvilableNum() + 1);
    257. 				}else{
    258. 					oldRoomType.setBookNum(oldRoomType.getBookNum() + 1);
    259. 				}
    260. 			}
    261. 			BookOrder newBookOrder = bookOrderService.find(bookOrderId);
    262. 			newBookOrder.setStatus(1);
    263. 			bookOrderService.edit(newBookOrder);
    264. 		}**/
    265. 		roomTypeService.updateNum(newRoomType);
    266. 		roomTypeService.updateNum(oldRoomType);
    267. 		//判断房间是否发生变化
    268. 		if(checkin.getRoomId().longValue() != existCheckin.getRoomId().longValue()){
    269. 			//表示房间发生了变化
    270. 			Room oldRoom = roomService.find(existCheckin.getRoomId());
    271. 			Room newRoom = roomService.find(checkin.getRoomId());
    272. 			oldRoom.setStatus(0);//原来的房间可入住
    273. 			newRoom.setStatus(1);//现在的房间已入住
    274. 			roomService.edit(newRoom);
    275. 			roomService.edit(oldRoom);
    276. 		}
    277. 		ret.put("type", "success");
    278. 		ret.put("msg", "修改成功!");
    279. 		return ret;
    280. 	}
    281. 	
    282. 	/**
    283. 	 * 分页查询入住信息
    284. 	 * @param name
    285. 	 * @param page
    286. 	 * @return
    287. 	 */
    288. 	@RequestMapping(value="/list",method=RequestMethod.POST)
    289. 	@ResponseBody
    290. 	public Map list(
    291. 			@RequestParam(name="name",defaultValue="") String name,
    292. 			@RequestParam(name="roomId",defaultValue="") Long roomId,
    293. 			@RequestParam(name="roomTypeId",defaultValue="") Long roomTypeId,
    294. 			@RequestParam(name="idCard",defaultValue="") String idCard,
    295. 			@RequestParam(name="mobile",defaultValue="") String mobile,
    296. 			@RequestParam(name="status",required=false) Integer status,
    297. 			Page page
    298. 			){
    299. 		Map ret = new HashMap();
    300. 		Map queryMap = new HashMap();
    301. 		queryMap.put("name", name);
    302. 		queryMap.put("status", status);
    303. 		queryMap.put("roomId", roomId);
    304. 		queryMap.put("roomTypeId", roomTypeId);
    305. 		queryMap.put("idCard", idCard);
    306. 		queryMap.put("mobile", mobile);
    307. 		queryMap.put("offset", page.getOffset());
    308. 		queryMap.put("pageSize", page.getRows());
    309. 		ret.put("rows", checkinService.findList(queryMap));
    310. 		ret.put("total", checkinService.getTotal(queryMap));
    311. 		return ret;
    312. 	}
    313. 	
    314. 	/**
    315. 	 * 退房操作
    316. 	 * @param checkId
    317. 	 * @return
    318. 	 */
    319. 	@RequestMapping(value="/checkout",method=RequestMethod.POST)
    320. 	@ResponseBody
    321. 	public Map checkout(Long checkId
    322. 			){
    323. 		Map ret = new HashMap();
    324. 		if(checkId == null){
    325. 			ret.put("type", "error");
    326. 			ret.put("msg", "请选择数据!");
    327. 			return ret;
    328. 		}
    329. 		Checkin checkin = checkinService.find(checkId);
    330. 		if(checkin == null){
    331. 			ret.put("type", "error");
    332. 			ret.put("msg", "请选择正确的数据!");
    333. 			return ret;
    334. 		}
    335. 		checkin.setStatus(1);
    336. 		if(checkinService.edit(checkin) <= 0){
    337. 			ret.put("type", "error");
    338. 			ret.put("msg", "退房失败，请联系管理员!");
    339. 			return ret;
    340. 		}
    341. 		//首先操作房间状态
    342. 		Room room = roomService.find(checkin.getRoomId());
    343. 		if(room != null){
    344. 			room.setStatus(2);
    345. 			roomService.edit(room);
    346. 		}
    347. 		//其次修改房型可用数、入住数、状态
    348. 		RoomType roomType = roomTypeService.find(checkin.getRoomTypeId());
    349. 		if(roomType != null){
    350. 			roomType.setAvilableNum(roomType.getAvilableNum() + 1);
    351. 			if(roomType.getAvilableNum() > roomType.getRoomNum()){
    352. 				roomType.setAvilableNum(roomType.getRoomNum());
    353. 			}
    354. 			roomType.setLivedNum(roomType.getLivedNum() - 1);
    355. 			if(roomType.getStatus() == 0){
    356. 				roomType.setStatus(1);
    357. 			}
    358. 			if(checkin.getBookOrderId() != null){
    359. 				roomType.setBookNum(roomType.getBookNum() - 1);
    360. 			}
    361. 			roomTypeService.updateNum(roomType);
    362. 			roomTypeService.edit(roomType);
    363. 		}
    364. 		//判断是否来自预定
    365. 		if(checkin.getBookOrderId() != null){
    366. 			BookOrder bookOrder = bookOrderService.find(checkin.getBookOrderId());
    367. 			bookOrder.setStatus(2);
    368. 			bookOrderService.edit(bookOrder);
    369. 			
    370. 		}
    371. 		ret.put("type", "success");
    372. 		ret.put("msg", "退房成功!");
    373. 		return ret;
    374. 	}
    375. 	
    376. 	/**
    377. 	 * 根据房间类型获取房间
    378. 	 * @param roomTypeId
    379. 	 * @return
    380. 	 */
    381. 	@RequestMapping(value="/load_room_list",method=RequestMethod.POST)
    382. 	@ResponseBody
    383. 	public List> load_room_list(Long roomTypeId){
    384. 		List> retList = new ArrayList>();
    385. 		Map queryMap = new HashMap();
    386. 		queryMap.put("roomTypeId", roomTypeId);
    387. 		queryMap.put("status", 0);
    388. 		queryMap.put("offset", 0);
    389. 		queryMap.put("pageSize", 999);
    390. 		List roomList = roomService.findList(queryMap);
    391. 		for(Room room:roomList){
    392. 			Map option = new HashMap();
    393. 			option.put("value", room.getId());
    394. 			option.put("text", room.getSn());
    395. 			retList.add(option);
    396. 		}
    397. 		return retList;
    398. 	}
    399. }

    五，项目总结

    随着社会的发展，酒店管理系统在国内外的发展都有了不小的成就，在国家发展到80年代至90年代的时候，国内的酒店管理系统已经开始发展起来了，充分接纳了国外酒店管理系统的管理模式，再结合国内酒店行业的实际情况，在已形成了几个较为成熟的软件系统的同时，产生了几家专职从事酒店业管理系统的公司。到了后期，随着计算机在酒店中的普及应用，计算机技术的不断发展，酒店管理系统的发展到了一个新的时期，新的系统平台、新的系统特点及发展方向不断涌现，功能更加细致完善，系统更加稳定可靠。但是也存在着不少的问题，如需求不明确、没有行业统一的标准等等，使得大型的酒店可以使用的上很多的功能，以至于小型的酒店在系统的使用上得不到满足。因此提供一套完善的中小型酒店管理软件是必不可少的。一套完善的酒店管理软件有利于提高宾馆的综合服务水平，更是帮助酒店管理好内部的秩序，减少工作量。

  • 相关阅读:
    java序列化与反序列化
    Retrofit解密：接口请求是如何适配suspend协程？
    WebSocket Day03 : SpringMVC整合WebSocket
    零零信安-D&D数据泄露报警日报【第29期】
    【UE】材质描边、外发光、轮廓线
    代码重构：面向单元测试
    使用Spark探索数据
    /node_modules/XXX/index.js:XXX XXX ??= X；SyntaxError: Unexpected token ‘??=‘
    北大肖臻老师《区块链技术与应用》系列课程学习笔记[26]以太坊-TheDao
    【HTML——三维立体隧道】（效果+代码）
  • 原文地址：https://blog.csdn.net/whirlwind526/article/details/127775586