0
0

Java项目:YY酒店管理系统(java+JSP+Easyui+Echars+ssm+mysql)

源码获取：博客首页 "资源" 里下载！

基础环境

搭建环境

  • Tomcat 8.5
  • Java 1.8+
  • Mysql 5.7

涉及技术

Spring、Mybatis、MySql、easyui、h-ui、Jsp、echars

项目介绍

酒店管理系统的目标是为用户提供高效的服务，减少手工处理的繁琐与误差，及时准确地反映酒店工作情况、经营信息，从而提高酒店工作质量，获得更好的经济效益，实现客房管理的规范化、自动化。具体目标包括：

  • 高效的客房预订及订单处理。
  • 准确无误地记录客人每笔消费信息。
  • 实时、快速、准确提供客房动态。
  • 酒店收益的最终统计。
  • 系统运行稳定可靠、各项维护功能齐全、易于维护。
  • 简单、友好的操作界面

前台页面：
模块主要功能酒店信息展示客房信息展示、房间状态查询、房间预定、客房信息检索、会员用户预订会员注册登录、用户中心、订单查询、用户信息修改、用户密码修改
后台页面：
模块主要功能系统设置菜单管理、角色管理、修改密码用户管理用户列表管理系统日志日志列表酒店管理楼层管理、房型管理、房间管理、客户管理、预订管理、入住管理营业统计统计图标

客户管理后台控制器:

  1. /**
  2.  * 客户管理后台控制器
  3.  * @author yy
  4.  *
  5.  */
  6. @RequestMapping("/admin/account")
  7. @Controller
  8. public class AccountController {
  9.     
  10.     @Autowired
  11.     private AccountService accountService;
  12.     
  13.     
  14.     /**
  15.      * 客户管理列表页面
  16.      * @param model
  17.      * @return
  18.      */
  19.     @RequestMapping(value="/list",method=RequestMethod.GET)
  20.     public ModelAndView list(ModelAndView model){
  21.         model.setViewName("account/list");
  22.         return model;
  23.     }
  24.     
  25.     /**
  26.      * 客户信息添加操作
  27.      * @param account
  28.      * @return
  29.      */
  30.     @RequestMapping(value="/add",method=RequestMethod.POST)
  31.     @ResponseBody
  32.     public Map<String, String> add(Account account){
  33.         Map<String, String> ret = new HashMap<String, String>();
  34.         if(account == null){
  35.             ret.put("type", "error");
  36.             ret.put("msg", "请填写正确的客户信息!");
  37.             return ret;
  38.         }
  39.         if(StringUtils.isEmpty(account.getName())){
  40.             ret.put("type", "error");
  41.             ret.put("msg", "客户名称不能为空!");
  42.             return ret;
  43.         }
  44.         if(StringUtils.isEmpty(account.getPassword())){
  45.             ret.put("type", "error");
  46.             ret.put("msg", "客户密码不能为空!");
  47.             return ret;
  48.         }
  49.         if(isExist(account.getName(), 0l)){
  50.             ret.put("type", "error");
  51.             ret.put("msg", "该用户名已经存在!");
  52.             return ret;
  53.         }
  54.         if(accountService.add(account) <= 0){
  55.             ret.put("type", "error");
  56.             ret.put("msg", "添加失败，请联系管理员!");
  57.             return ret;
  58.         }
  59.         ret.put("type", "success");
  60.         ret.put("msg", "添加成功!");
  61.         return ret;
  62.     }
  63.     
  64.     /**
  65.      * 客户信息编辑操作
  66.      * @param account
  67.      * @return
  68.      */
  69.     @RequestMapping(value="/edit",method=RequestMethod.POST)
  70.     @ResponseBody
  71.     public Map<String, String> edit(Account account){
  72.         Map<String, String> ret = new HashMap<String, String>();
  73.         if(account == null){
  74.             ret.put("type", "error");
  75.             ret.put("msg", "请填写正确的客户信息!");
  76.             return ret;
  77.         }
  78.         if(StringUtils.isEmpty(account.getName())){
  79.             ret.put("type", "error");
  80.             ret.put("msg", "客户名称不能为空!");
  81.             return ret;
  82.         }
  83.         if(StringUtils.isEmpty(account.getPassword())){
  84.             ret.put("type", "error");
  85.             ret.put("msg", "客户密码不能为空!");
  86.             return ret;
  87.         }
  88.         if(isExist(account.getName(), account.getId())){
  89.             ret.put("type", "error");
  90.             ret.put("msg", "该用户名已经存在!");
  91.             return ret;
  92.         }
  93.         if(accountService.edit(account) <= 0){
  94.             ret.put("type", "error");
  95.             ret.put("msg", "添加失败，请联系管理员!");
  96.             return ret;
  97.         }
  98.         ret.put("type", "success");
  99.         ret.put("msg", "修改成功!");
  100.         return ret;
  101.     }
  102.     
  103.     /**
  104.      * 分页查询客户信息
  105.      * @param name
  106.      * @param page
  107.      * @return
  108.      */
  109.     @RequestMapping(value="/list",method=RequestMethod.POST)
  110.     @ResponseBody
  111.     public Map<String,Object> list(
  112.             @RequestParam(name="name",defaultValue="") String name,
  113.             @RequestParam(name="realName",defaultValue="") String realName,
  114.             @RequestParam(name="idCard",defaultValue="") String idCard,
  115.             @RequestParam(name="mobile",defaultValue="") String mobile,
  116.             @RequestParam(name="status",required=false) Integer status,
  117.             Page page
  118.             ){
  119.         Map<String,Object> ret = new HashMap<String, Object>();
  120.         Map<String,Object> queryMap = new HashMap<String, Object>();
  121.         queryMap.put("name", name);
  122.         queryMap.put("status", status);
  123.         queryMap.put("realName", realName);
  124.         queryMap.put("idCard", idCard);
  125.         queryMap.put("mobile", mobile);
  126.         queryMap.put("offset", page.getOffset());
  127.         queryMap.put("pageSize", page.getRows());
  128.         ret.put("rows", accountService.findList(queryMap));
  129.         ret.put("total", accountService.getTotal(queryMap));
  130.         return ret;
  131.     }
  132.     
  133.     /**
  134.      * 客户信息删除操作
  135.      * @param id
  136.      * @return
  137.      */
  138.     @RequestMapping(value="/delete",method=RequestMethod.POST)
  139.     @ResponseBody
  140.     public Map<String, String> delete(Long id){
  141.         Map<String, String> ret = new HashMap<String, String>();
  142.         if(id == null){
  143.             ret.put("type", "error");
  144.             ret.put("msg", "请选择要删除的信息!");
  145.             return ret;
  146.         }
  147.         try {
  148.             if(accountService.delete(id) <= 0){
  149.                 ret.put("type", "error");
  150.                 ret.put("msg", "删除失败，请联系管理员!");
  151.                 return ret;
  152.             }
  153.         } catch (Exception e) {
  154.             // TODO: handle exception
  155.             ret.put("type", "error");
  156.             ret.put("msg", "该客户下存在订单信息，请先删除该客户下的所有订单信息!");
  157.             return ret;
  158.         }
  159.         ret.put("type", "success");
  160.         ret.put("msg", "删除成功!");
  161.         return ret;
  162.     }
  163.     
  164.     /**
  165.      * 判断用户名是否存在
  166.      * @param name
  167.      * @param id
  168.      * @return
  169.      */
  170.     private boolean isExist(String name,Long id){
  171.         Account findByName = accountService.findByName(name);
  172.         if(findByName == null)return false;
  173.         if(findByName.getId().longValue() == id.longValue())return false;
  174.         return true;
  175.     }
  176. }

角色role控制器:

  1. /**
  2.  * 角色role控制器
  3.  * @author yy
  4.  *
  5.  */
  6. @RequestMapping("/admin/role")
  7. @Controller
  8. public class RoleController {
  9.     
  10.     @Autowired
  11.     private RoleService roleService;
  12.     
  13.     @Autowired
  14.     private AuthorityService authorityService;
  15.     
  16.     @Autowired
  17.     private MenuService menuService;
  18.     
  19.     /**
  20.      * 角色列表页面
  21.      * @param model
  22.      * @return
  23.      */
  24.     @RequestMapping(value="/list",method=RequestMethod.GET)
  25.     public ModelAndView list(ModelAndView model){
  26.         model.setViewName("/role/list");
  27.         return model;
  28.     }
  29.     
  30.     
  31.     /**
  32.      * 获取角色列表
  33.      * @param page
  34.      * @param name
  35.      * @return
  36.      */
  37.     @RequestMapping(value="/list",method=RequestMethod.POST)
  38.     @ResponseBody
  39.     public Map<String, Object> getList(Page page,
  40.             @RequestParam(name="name",required=false,defaultValue="") String name
  41.             ){
  42.         Map<String, Object> ret = new HashMap<String, Object>();
  43.         Map<String, Object> queryMap = new HashMap<String, Object>();
  44.         queryMap.put("name", name);
  45.         queryMap.put("offset", page.getOffset());
  46.         queryMap.put("pageSize", page.getRows());
  47.         ret.put("rows", roleService.findList(queryMap));
  48.         ret.put("total", roleService.getTotal(queryMap));
  49.         return ret;
  50.     }
  51.     
  52.     /**
  53.      * 角色添加
  54.      * @param role
  55.      * @return
  56.      */
  57.     @RequestMapping(value="/add",method=RequestMethod.POST)
  58.     @ResponseBody
  59.     public Map<String, String> add(Role role){
  60.         Map<String, String> ret = new HashMap<String, String>();
  61.         if(role == null){
  62.             ret.put("type", "error");
  63.             ret.put("msg", "请填写正确的角色信息！");
  64.             return ret;
  65.         }
  66.         if(StringUtils.isEmpty(role.getName())){
  67.             ret.put("type", "error");
  68.             ret.put("msg", "请填写角色名称！");
  69.             return ret;
  70.         }
  71.         if(roleService.add(role) <= 0){
  72.             ret.put("type", "error");
  73.             ret.put("msg", "角色添加失败，请联系管理员！");
  74.             return ret;
  75.         }
  76.         ret.put("type", "success");
  77.         ret.put("msg", "角色添加成功！");
  78.         return ret;
  79.     }
  80.     
  81.     /**
  82.      * 角色修改
  83.      * @param role
  84.      * @return
  85.      */
  86.     @RequestMapping(value="/edit",method=RequestMethod.POST)
  87.     @ResponseBody
  88.     public Map<String, String> edit(Role role){
  89.         Map<String, String> ret = new HashMap<String, String>();
  90.         if(role == null){
  91.             ret.put("type", "error");
  92.             ret.put("msg", "请填写正确的角色信息！");
  93.             return ret;
  94.         }
  95.         if(StringUtils.isEmpty(role.getName())){
  96.             ret.put("type", "error");
  97.             ret.put("msg", "请填写角色名称！");
  98.             return ret;
  99.         }
  100.         if(roleService.edit(role) <= 0){
  101.             ret.put("type", "error");
  102.             ret.put("msg", "角色修改失败，请联系管理员！");
  103.             return ret;
  104.         }
  105.         ret.put("type", "success");
  106.         ret.put("msg", "角色修改成功！");
  107.         return ret;
  108.     }
  109.     
  110.     /**
  111.      * 删除角色信息
  112.      * @param id
  113.      * @return
  114.      */
  115.     @RequestMapping(value="/delete",method=RequestMethod.POST)
  116.     @ResponseBody
  117.     public Map<String, String> delete(Long id){
  118.         Map<String, String> ret = new HashMap<String, String>();
  119.         if(id == null){
  120.             ret.put("type", "error");
  121.             ret.put("msg", "请选择要删除的角色！");
  122.             return ret;
  123.         }
  124.         try {
  125.             if(roleService.delete(id) <= 0){
  126.                 ret.put("type", "error");
  127.                 ret.put("msg", "删除失败，请联系管理员！");
  128.                 return ret;
  129.             }
  130.         } catch (Exception e) {
  131.             // TODO: handle exception
  132.             ret.put("type", "error");
  133.             ret.put("msg", "该角色下存在权限或者用户信息，不能删除！");
  134.             return ret;
  135.         }
  136.         ret.put("type", "success");
  137.         ret.put("msg", "角色删除成功！");
  138.         return ret;
  139.     }
  140.     
  141.     /**
  142.      * 获取所有的菜单信息
  143.      * @return
  144.      */
  145.     @RequestMapping(value="/get_all_menu",method=RequestMethod.POST)
  146.     @ResponseBody
  147.     public List<Menu> getAllMenu(){
  148.         Map<String, Object> queryMap = new HashMap<String, Object>();
  149.         queryMap.put("offset", 0);
  150.         queryMap.put("pageSize", 99999);
  151.         return menuService.findList(queryMap);
  152.     }
  153.     
  154.     /**
  155.      * 添加权限
  156.      * @param ids
  157.      * @return
  158.      */
  159.     @RequestMapping(value="/add_authority",method=RequestMethod.POST)
  160.     @ResponseBody
  161.     public Map<String, String> addAuthority(
  162.             @RequestParam(name="ids",required=true) String ids,
  163.             @RequestParam(name="roleId",required=true) Long roleId
  164.             ){
  165.         Map<String,String> ret = new HashMap<String, String>();
  166.         if(StringUtils.isEmpty(ids)){
  167.             ret.put("type", "error");
  168.             ret.put("msg", "请选择相应的权限！");
  169.             return ret;
  170.         }
  171.         if(roleId == null){
  172.             ret.put("type", "error");
  173.             ret.put("msg", "请选择相应的角色！");
  174.             return ret;
  175.         }
  176.         if(ids.contains(",")){
  177.             ids = ids.substring(0,ids.length()-1);
  178.         }
  179.         String[] idArr = ids.split(",");
  180.         if(idArr.length > 0){
  181.             authorityService.deleteByRoleId(roleId);
  182.         }
  183.         for(String id:idArr){
  184.             Authority authority = new Authority();
  185.             authority.setMenuId(Long.valueOf(id));
  186.             authority.setRoleId(roleId);
  187.             authorityService.add(authority);
  188.         }
  189.         ret.put("type", "success");
  190.         ret.put("msg", "权限编辑成功！");
  191.         return ret;
  192.     }
  193.     
  194.     /**
  195.      * 获取某个角色的所有权限
  196.      * @param roleId
  197.      * @return
  198.      */
  199.     @RequestMapping(value="/get_role_authority",method=RequestMethod.POST)
  200.     @ResponseBody
  201.     public List<Authority> getRoleAuthority(
  202.             @RequestParam(name="roleId",required=true) Long roleId
  203.         ){
  204.         return authorityService.findListByRoleId(roleId);
  205.     }
  206. }

前台首页控制器:

  1. /**
  2.  * 前台首页控制器
  3.  * @author yy
  4.  *
  5.  */
  6. @RequestMapping("/home")
  7. @Controller
  8. public class HomeController {
  9.     
  10.     @Autowired
  11.     private RoomTypeService roomTypeService;
  12.     @Autowired
  13.     private AccountService accountService;
  14.     
  15.     /**
  16.      * 前台首页
  17.      * @param model
  18.      * @param name
  19.      * @return
  20.      */
  21.     @RequestMapping(value="/index",method=RequestMethod.GET)
  22.     public ModelAndView list(ModelAndView model,
  23.             @RequestParam(name="name",defaultValue="") String name
  24.             ){
  25.         Map<String,Object> queryMap = new HashMap<String, Object>();
  26.         queryMap.put("name", name);
  27.         queryMap.put("offset", 0);
  28.         queryMap.put("pageSize", 999);
  29.         model.addObject("roomTypeList", roomTypeService.findList(queryMap));
  30.         model.setViewName("home/index/index");
  31.         model.addObject("kw", name);
  32.         return model;
  33.     }
  34.     
  35.     /**
  36.      * 登录页面
  37.      * @param model
  38.      * @return
  39.      */
  40.     @RequestMapping(value="/login",method=RequestMethod.GET)
  41.     public ModelAndView login(ModelAndView model
  42.             ){
  43.         model.setViewName("home/index/login");
  44.         return model;
  45.     }
  46.     
  47.     /**
  48.      * 注册页面
  49.      * @param model
  50.      * @return
  51.      */
  52.     @RequestMapping(value="/reg",method=RequestMethod.GET)
  53.     public ModelAndView reg(ModelAndView model
  54.             ){
  55.         model.setViewName("home/index/reg");
  56.         return model;
  57.     }
  58.     
  59.     /**
  60.      * 登录信息提交
  61.      * @param account
  62.      * @return
  63.      */
  64.     @RequestMapping(value="/login",method=RequestMethod.POST)
  65.     @ResponseBody
  66.     public Map<String,String> loginAct(Account account,String vcode,HttpServletRequest request){
  67.         Map<String,String> retMap = new HashMap<String, String>();
  68.         if(account == null){
  69.             retMap.put("type", "error");
  70.             retMap.put("msg", "请填写正确的用户信息！");
  71.             return retMap;
  72.         }
  73.         if(StringUtils.isEmpty(account.getName())){
  74.             retMap.put("type", "error");
  75.             retMap.put("msg", "用户名不能为空！");
  76.             return retMap;
  77.         }
  78.         if(StringUtils.isEmpty(account.getPassword())){
  79.             retMap.put("type", "error");
  80.             retMap.put("msg", "密码不能为空！");
  81.             return retMap;
  82.         }
  83.         if(StringUtils.isEmpty(vcode)){
  84.             retMap.put("type", "error");
  85.             retMap.put("msg", "验证码不能为空！");
  86.             return retMap;
  87.         }
  88.         Object attribute = request.getSession().getAttribute("accountLoginCpacha");
  89.         if(attribute == null){
  90.             retMap.put("type", "error");
  91.             retMap.put("msg", "验证码过期，请刷新！");
  92.             return retMap;
  93.         }
  94.         if(!vcode.equalsIgnoreCase(attribute.toString())){
  95.             retMap.put("type", "error");
  96.             retMap.put("msg", "验证码错误！");
  97.             return retMap;
  98.         }
  99.         Account findByName = accountService.findByName(account.getName());
  100.         if(findByName == null){
  101.             retMap.put("type", "error");
  102.             retMap.put("msg", "用户名不存在！");
  103.             return retMap;
  104.         }
  105.         if(!account.getPassword().equals(findByName.getPassword())){
  106.             retMap.put("type", "error");
  107.             retMap.put("msg", "密码错误！");
  108.             return retMap;
  109.         }
  110.         if(findByName.getStatus() == -1){
  111.             retMap.put("type", "error");
  112.             retMap.put("msg", "该用户已被禁用，请联系管理员！");
  113.             return retMap;
  114.         }
  115.         request.getSession().setAttribute("account", findByName);
  116.         request.getSession().setAttribute("accountLoginCpacha", null);
  117.         retMap.put("type", "success");
  118.         retMap.put("msg", "登录成功！");
  119.         return retMap;
  120.     }
  121.     
  122.     /**
  123.      * 注册信息提交
  124.      * @param account
  125.      * @return
  126.      */
  127.     @RequestMapping(value="/reg",method=RequestMethod.POST)
  128.     @ResponseBody
  129.     public Map<String,String> regAct(Account account){
  130.         Map<String,String> retMap = new HashMap<String, String>();
  131.         if(account == null){
  132.             retMap.put("type", "error");
  133.             retMap.put("msg", "请填写正确的用户信息！");
  134.             return retMap;
  135.         }
  136.         if(StringUtils.isEmpty(account.getName())){
  137.             retMap.put("type", "error");
  138.             retMap.put("msg", "用户名不能为空！");
  139.             return retMap;
  140.         }
  141.         if(StringUtils.isEmpty(account.getPassword())){
  142.             retMap.put("type", "error");
  143.             retMap.put("msg", "密码不能为空！");
  144.             return retMap;
  145.         }
  146.         if(StringUtils.isEmpty(account.getMobile())){
  147.             retMap.put("type", "error");
  148.             retMap.put("msg", "手机号不能为空！");
  149.             return retMap;
  150.         }
  151.         if(isExist(account.getName())){
  152.             retMap.put("type", "error");
  153.             retMap.put("msg", "该用户名已经存在！");
  154.             return retMap;
  155.         }
  156.         if(accountService.add(account) <= 0){
  157.             retMap.put("type", "error");
  158.             retMap.put("msg", "注册失败，请联系管理员！");
  159.             return retMap;
  160.         }
  161.         retMap.put("type", "success");
  162.         retMap.put("msg", "注册成功！");
  163.         return retMap;
  164.     }
  165.     
  166.     /**
  167.      * 退出登录
  168.      * @param request
  169.      * @return
  170.      */
  171.     @RequestMapping(value="/logout",method=RequestMethod.GET)
  172.     public String logout(HttpServletRequest request){
  173.         request.getSession().setAttribute("account", null);
  174.         return "redirect:login";
  175.     }
  176.     
  177.     private boolean isExist(String name){
  178.         Account account = accountService.findByName(name);
  179.         if(account == null)return false;
  180.         return true;
  181.     }
  182. }

前台用户控制器:

  1. /**
  2.  * 前台用户控制器
  3.  * @author yy
  4.  *
  5.  */
  6. @RequestMapping("/home/account")
  7. @Controller
  8. public class HomeAccountController {
  9.     
  10.     @Autowired
  11.     private RoomTypeService roomTypeService;
  12.     @Autowired
  13.     private AccountService accountService;
  14.     @Autowired
  15.     private BookOrderService bookOrderService;
  16.     
  17.     /**
  18.      * 前台用户中心首页
  19.      * @param model
  20.      * @param name
  21.      * @return
  22.      */
  23.     @RequestMapping(value="/index",method=RequestMethod.GET)
  24.     public ModelAndView list(ModelAndView model,HttpServletRequest request
  25.             ){
  26.         Account account = (Account)request.getSession().getAttribute("account");
  27.         Map<String,Object> queryMap = new HashMap<String, Object>();
  28.         queryMap.put("accountId", account.getId());
  29.         queryMap.put("offset", 0);
  30.         queryMap.put("pageSize", 999);
  31.         model.addObject("bookOrderList", bookOrderService.findList(queryMap));
  32.         model.addObject("roomTypeList", roomTypeService.findAll());
  33.         model.setViewName("home/account/index");
  34.         return model;
  35.     }
  36.     
  37.     /**
  38.      * 预定房间页面
  39.      * @param model
  40.      * @return
  41.      */
  42.     @RequestMapping(value="/book_order",method=RequestMethod.GET)
  43.     public ModelAndView bookOrder(ModelAndView model,Long roomTypeId
  44.             ){
  45.         model.addObject("roomType", roomTypeService.find(roomTypeId));
  46.         model.setViewName("home/account/book_order");
  47.         return model;
  48.     }
  49.     
  50.     
  51.     /**
  52.      * 预定信息提交
  53.      * @param account
  54.      * @return
  55.      */
  56.     @RequestMapping(value="/book_order",method=RequestMethod.POST)
  57.     @ResponseBody
  58.     public Map<String,String> bookOrderAct(BookOrder bookOrder,HttpServletRequest request){
  59.         Map<String, String> ret = new HashMap<String, String>();
  60.         if(bookOrder == null){
  61.             ret.put("type", "error");
  62.             ret.put("msg", "请填写正确的预定订单信息!");
  63.             return ret;
  64.         }
  65.         Account account = (Account)request.getSession().getAttribute("account");
  66.         if(account == null){
  67.             ret.put("type", "error");
  68.             ret.put("msg", "客户不能为空!");
  69.             return ret;
  70.         }
  71.         bookOrder.setAccountId(account.getId());
  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.         bookOrder.setStatus(0);
  104.         if(bookOrderService.add(bookOrder) <= 0){
  105.             ret.put("type", "error");
  106.             ret.put("msg", "添加失败，请联系管理员!");
  107.             return ret;
  108.         }
  109.         RoomType roomType = roomTypeService.find(bookOrder.getRoomTypeId());
  110.         //预定成功后去修改该房型的预定数
  111.         if(roomType != null){
  112.             roomType.setBookNum(roomType.getBookNum() + 1);
  113.             roomType.setAvilableNum(roomType.getAvilableNum() - 1);
  114.             roomTypeService.updateNum(roomType);
  115.             //如果可用的房间数为0，则设置该房型状态已满
  116.             if(roomType.getAvilableNum() == 0){
  117.                 roomType.setStatus(0);
  118.                 roomTypeService.edit(roomType);
  119.             }
  120.         }
  121.         ret.put("type", "success");
  122.         ret.put("msg", "预定成功!");
  123.         return ret;
  124.     }
  125.     
  126.     /**
  127.      * 修改个人信息提交
  128.      * @param account
  129.      * @return
  130.      */
  131.     @RequestMapping(value="/update_info",method=RequestMethod.POST)
  132.     @ResponseBody
  133.     public Map<String,String> updateInfoAct(Account account,HttpServletRequest request){
  134.         Map<String,String> retMap = new HashMap<String, String>();
  135.         if(account == null){
  136.             retMap.put("type", "error");
  137.             retMap.put("msg", "请填写正确的用户信息！");
  138.             return retMap;
  139.         }
  140.         if(StringUtils.isEmpty(account.getName())){
  141.             retMap.put("type", "error");
  142.             retMap.put("msg", "用户名不能为空！");
  143.             return retMap;
  144.         }
  145.         Account loginedAccount = (Account)request.getSession().getAttribute("account");
  146.         if(isExist(account.getName(),loginedAccount.getId())){
  147.             retMap.put("type", "error");
  148.             retMap.put("msg", "该用户名已经存在！");
  149.             return retMap;
  150.         }
  151.         loginedAccount.setAddress(account.getAddress());
  152.         loginedAccount.setIdCard(account.getIdCard());
  153.         loginedAccount.setMobile(account.getMobile());
  154.         loginedAccount.setName(account.getName());
  155.         loginedAccount.setRealName(account.getRealName());
  156.         if(accountService.edit(loginedAccount) <= 0){
  157.             retMap.put("type", "error");
  158.             retMap.put("msg", "修改失败，请联系管理员！");
  159.             return retMap;
  160.         }
  161.         request.getSession().setAttribute("account", loginedAccount);
  162.         retMap.put("type", "success");
  163.         retMap.put("msg", "修改成功！");
  164.         return retMap;
  165.     }
  166.     
  167.     /**
  168.      * 修改密码提交
  169.      * @param account
  170.      * @return
  171.      */
  172.     @RequestMapping(value="/update_pwd",method=RequestMethod.POST)
  173.     @ResponseBody
  174.     public Map<String,String> updatePwdAct(String oldPassword,String newPassword,HttpServletRequest request){
  175.         Map<String,String> retMap = new HashMap<String, String>();
  176.         if(StringUtils.isEmpty(oldPassword)){
  177.             retMap.put("type", "error");
  178.             retMap.put("msg", "请填写原来的密码！");
  179.             return retMap;
  180.         }
  181.         if(StringUtils.isEmpty(newPassword)){
  182.             retMap.put("type", "error");
  183.             retMap.put("msg", "请填写新密码！");
  184.             return retMap;
  185.         }
  186.         Account loginedAccount = (Account)request.getSession().getAttribute("account");
  187.         if(!oldPassword.equals(loginedAccount.getPassword())){
  188.             retMap.put("type", "error");
  189.             retMap.put("msg", "原密码错误！");
  190.             return retMap;
  191.         }
  192.         loginedAccount.setPassword(newPassword);
  193.         if(accountService.edit(loginedAccount) <= 0){
  194.             retMap.put("type", "error");
  195.             retMap.put("msg", "修改失败，请联系管理员！");
  196.             return retMap;
  197.         }
  198.         retMap.put("type", "success");
  199.         retMap.put("msg", "修改密码成功！");
  200.         return retMap;
  201.     }
  202.     
  203.     /**
  204.      * 判断用户是否存在
  205.      * @param name
  206.      * @param id
  207.      * @return
  208.      */
  209.     private boolean isExist(String name,Long id){
  210.         Account account = accountService.findByName(name);
  211.         if(account == null)return false;
  212.         if(account != null && account.getId().longValue() == id)return false;
  213.         return true;
  214.     }
  215. }

源码获取：博客首页 "资源" 里下载！

标签： mysql java ssm
本文转载自: https://blog.csdn.net/yuyecsdn/article/details/124047258
版权归原作者 pastclouds 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java项目:YY酒店管理系统(java+JSP+Easyui+Echars+ssm+mysql)”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？