基于javaweb+mysql的springboot在线电影售票系统设计和实现(java+springboot+jpa+mysql+freemarker+maven)

基于javaweb+mysql的springboot在线电影售票系统设计和实现(java+springboot+jpa+mysql+freemarker+maven)

运行环境

Java≥8、MySQL≥5.7

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SpringBoot在线电影售票系统设计和实现(java+springboot+jpa+mysql+freemarker+maven)

一、项目简述

前台：

1、正在上映的电影浏览查看。

2、影院信息浏览查看。

3、新闻咨询信息浏览查看。

4、地域信息查看切换。

5、用户注册登录。

6、电影排期查看。

7、在线选座生成订单并支付。

8、电影、影院的评价及评价浏览。

9、用户个人中心。

10、用户中心订单管理。

11、用户中心余额充值。

12、用户中心电影评价、影院评价管理。

后台：

1、地域管理。

2、电影管理、电影评价管理。

3、影院管理、影院评价管理。

4、影厅管理。

5、拍片场次管理。

6、新闻咨询管理。

7、用户管理。

8、订单管理。

9、支付管理。

10、统计类：包括用户、电影、影院、票房等等的统计。

二、项目运行

环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持)

项目技术： Springboot+ SpringMVC + Spring Data JPA + freemarker + JavaScript + JQuery + Ajax + maven等等

		if(accountService.save(loginedAccount) == null){
			return Result.error(CodeMsg.SAVE_ERROR);
		}
		//表示用户已经修改成功，放入session
		SessionUtil.set(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY, loginedAccount);
		return Result.success(true);
	}
	
	/**
	 * 修改密码
	 * @param password
	 * @return
	 */
	@RequestMapping(value="/update_pwd",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> updatePwd(
			@RequestParam(name="password",required=true)String password
			){

		//短信验证码正确
		Account account = (Account)SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		account.setPassword(password);
		accountService.save(account);
		//放入session
		SessionUtil.set(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY, account);
		return Result.success(true);
	}
	
	/**
	 * 生成支付记录
	 * @param payLog
	 * @return
	 */
	@RequestMapping(value="/generate_pay_log",method=RequestMethod.POST)
	@ResponseBody
	public Result<String> generatePayLog(PayLog payLog){
		Account account = (Account)SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		payLog.setAccount(account);
		payLog.setSn(StringUtil.generateSn());
		payLogService.save(payLog);
		account.setBalance(account.getBalance().add(payLog.getMoney()));
		accountService.save(account);
		return Result.success(null);
	}
	
	/**
	 * 订单列表

		model.addAttribute("topNewsList", newsService.findTop());
		return "home/index/index";
	}
	
	/**
	 * 注册页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/register",method=RequestMethod.GET)
	public String register(Model model){
		Account account = (Account) SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		if(account != null){
			return "redirect:/home/account/user-center";
		}
		return "home/index/register";
	}
	
	/**
	 * 退出登录
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/logout",method=RequestMethod.GET)
	public String logout(Model model){
		SessionUtil.set(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY, null);
		return "redirect:index";
	}
	
	/**
	 * 改变地域
	 * @param cid
	 * @return
	 */
	@RequestMapping(value="/change_area",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> changeArea(@RequestParam(name="cid",required=true)Long cid){
		Area area = areaService.findById(cid);
		if(area == null){
			return Result.error(CodeMsg.HOME_AREA_NO_EXIST);
		}
		SessionUtil.set(SessionConstant.SESSION_HOME_AREA, area);
		return Result.success(true);
	}
	
	/**
	 * 注册表单提交
	 * @param mobile
	 * @param password
	 * @param checkCode
	 * @return
	 */

	
	/**
	 * 删除订单
	 * @param sn
	 * @return
	 */
	@RequestMapping(value="/delete_order",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> deleteOrder(@RequestParam(name="order_sn",required=true)String sn){
		Order order = orderService.find(sn);
		if(order == null){
			return Result.error(CodeMsg.HOME_ORDER_NO_EXIST);
		}
		if(order.getStatus() == Order.status_paid){
			return Result.error(CodeMsg.HOME_ORDER_UNABLE_DELETE);
		}
		//先删除订单子项、再删除订单
		orderService.delete(order);
		return Result.success(true);
	}
}
package com.demo.controller.home;
/**
 * 订单控制器
 */

	private PayLogService payLogService;
	@Autowired
	private AccountService accountService;
	
	private Logger log = LoggerFactory.getLogger(PayController.class);
	
	@RequestMapping(value="/to_pay")
	public String toPay(@RequestParam(name="sn",required=true)String sn,Model model){
		PayLog payLog = payLogService.find(sn);
		if(payLog == null){
			model.addAttribute("msg", "支付记录不存在！");
			return RuntimeConstant.RUN_ERROR_VIEW;
		}
		if(payLog.getStatus() == PayLog.status_paid){
			model.addAttribute("msg", "已经支付成功，请勿重复发起支付！");
			return RuntimeConstant.RUN_ERROR_VIEW;
		}
		if(payLog.getMoney().compareTo(new BigDecimal(0)) <= 0){
			model.addAttribute("msg", "支付金额错误！");
			return RuntimeConstant.RUN_ERROR_VIEW;
		}
		//到这表示一切合法，根据支付方式调起支付
		switch (payLog.getPaymentType()) {
			case alipay:{
				String html = Alipay.generatePayHtml(payLog.getSn(), payLog.getMoney(), "用户充值", "用户【" + payLog.getAccount().getMobile() + "】充值【" + payLog.getMoney() + "】");
				model.addAttribute("payHtml", html);
				log.info("进入支付宝电脑网站支付");
				return "home/pay/alipay_pc";
			}
			default:
				break;
		}
		model.addAttribute("msg", "未定义的支付方式！");
		return RuntimeConstant.RUN_ERROR_VIEW;
	}
	
	/**
	 * 支付宝异步通知
	 * @param request
	 * @return

	public String noRight(){
		return "admin/system/no_right";
	}
	
	/**
	 * 修改用户个人信息
	 * @return
	 */
	@RequestMapping(value="/update_userinfo",method=RequestMethod.GET)
	public String updateUserInfo(){
		return "admin/system/update_userinfo";
	}
	
	/**
	 * 修改个人信息保存
	 * @param user
	 * @return
	 */
	@RequestMapping(value="/update_userinfo",method=RequestMethod.POST)
	public String updateUserInfo(User user){
		User loginedUser = SessionUtil.getLoginedUser();
		loginedUser.setEmail(user.getEmail());
		loginedUser.setMobile(user.getMobile());
		loginedUser.setHeadPic(user.getHeadPic());
		//首先保存到数据库
		userService.save(loginedUser);
		//更新session里的值
		SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, loginedUser);
		return "redirect:update_userinfo";
	}
	
	/**
	 * 修改密码页面
	 * @return
	 */
	@RequestMapping(value="/update_pwd",method=RequestMethod.GET)
	public String updatePwd(){
		return "admin/system/update_pwd";
	}
	
	/**
	 * 修改密码表单提交
	 * @param oldPwd
	 * @param newPwd
	 * @return
	 */
	@RequestMapping(value="/update_pwd",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> updatePwd(@RequestParam(name="oldPwd",required=true)String oldPwd,
			@RequestParam(name="newPwd",required=true)String newPwd
			){
		User loginedUser = SessionUtil.getLoginedUser();
		if(!loginedUser.getPassword().equals(oldPwd)){

        if (photo.getSize() / 1024 > uploadPhotoMaxSize) {
            CodeMsg codeMsg = CodeMsg.UPLOAD_PHOTO_ERROR;
            codeMsg.setMsg("图片大小不能超过" + (uploadPhotoMaxSize / 1024) + "M");
            return Result.error(codeMsg);
        }
        //准备保存文件
        File filePath = new File(uploadPhotoPath);
        if (!filePath.exists()) {
            //若不存在文件夹，则创建一个文件夹
            filePath.mkdir();
        }
        filePath = new File(uploadPhotoPath + "/" + StringUtil.getFormatterDate(new Date(), "yyyyMMdd"));
        //判断当天日期的文件夹是否存在，若不存在，则创建
        if (!filePath.exists()) {
            //若不存在文件夹，则创建一个文件夹
            filePath.mkdir();
        }
        String filename = StringUtil.getFormatterDate(new Date(), "yyyyMMdd") + "/" + System.currentTimeMillis() + suffix;
        try {
            photo.transferTo(new File(uploadPhotoPath + "/" + filename));
        } catch (IllegalStateException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        log.info("图片上传成功，保存位置：" + uploadPhotoPath + filename);
        return Result.success(filename);
    }

    /**
     * 上传视频
     *
     * @param video
     * @return
     */
    @RequestMapping(value = "/upload_video", method = RequestMethod.POST)
    @ResponseBody
    public Result<String> uploadVideo(@RequestParam(name = "video", required = true) MultipartFile video) {
        //判断文件类型是否是视频
        String originalFilename = video.getOriginalFilename();
        //获取文件后缀
        String suffix = originalFilename.substring(originalFilename.lastIndexOf("."), originalFilename.length());
        if (!uploadVideoSufix.contains(suffix.toLowerCase())) {
            return Result.error(CodeMsg.UPLOAD_VIDEO_ERROR);
        }
        if (video.getSize() / 1024 > uploadVideoMaxSize) {

			@RequestParam(name="cid",required=true) Long cid,
			@RequestParam(name="showDate",required=true) String showDate){
		model.addAttribute("cinemaHallSessionList", cinemaHallSessionService.findDistinctMovieByCinemaList(cid, showDate));
		return "home/cinema/get_show_movie";
	}
	
	/**
	 * 统计影院上映场次
	 * @param cinemaId
	 * @return
	 */
	@RequestMapping("/get_show_stats")
	@ResponseBody
	public Result<List<Integer>> getShowStats(@RequestParam(name="cid",required=true) Long cinemaId) {
		List<Integer> ret = new ArrayList<Integer>();
		List<Integer> showTotal = cinemaHallSessionService.getCinemaShowTotal(cinemaId);
		if(showTotal == null || showTotal.size() <= 0){
			ret.add(0);
			ret.add(0);
			return Result.success(ret);
		}
		ret.add(showTotal.size());//上映的电影数
		//计算场次数
		int totalSession = 0;
		for(int i=0; i< showTotal.size();i++){
			totalSession += Integer.parseInt(showTotal.get(i)+"");
		}
		ret.add(totalSession);
		return Result.success(ret);
	}
}
package com.demo.controller.admin;

			payLog.setStatus(PayLog.status_paid);
			payLogService.save(payLog);
			log.info("支付成功，用户最新余额=" + account.getBalance());
		}
		return "success";
	}
}
package com.demo.controller.home;

/**
 * 前台电影院控制器
 *
 */
@RequestMapping("/home/cinema")
@Controller
public class HomeCinemaController {

	@Autowired
	private MovieService movieService;
	@Autowired
	private NewsService newsService;
	@Autowired
	private CinemaHallSessionService cinemaHallSessionService;
	@Autowired
	private CinemaService cinemaService;
	@Autowired

/**
 * 项目通用工具类
 *
 */
public class StringUtil {
	
	
	/**
	 * 返回指定格式的日期字符串
	 * @param date
	 * @param formatter
	 * @return
	 */
	public static String getFormatterDate(Date date,String formatter){
		SimpleDateFormat sdf = new SimpleDateFormat(formatter);
		return sdf.format(date);
	}
	
	/**
	 * 判断请求是否是ajax
	 * @param request
	 * @return
	 */
	public static boolean isAjax(HttpServletRequest request){
		String header = request.getHeader("X-Requested-With");
		if("XMLHttpRequest".equals(header))return true;
		return false;
	}
	
	/**
	 * 从流读取字符串
	 * @param inputStream
	 * @return

	 * 修改头像页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/update-head-pic",method=RequestMethod.GET)
	public String updateHeadPic(Model model){
		return "home/account/update-head-pic";
	}
	
	/**
	 * 账户余额
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/user-account",method=RequestMethod.GET)
	public String userAccount(Model model){
		Account account = (Account)SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		account = accountService.findById(account.getId());
		SessionUtil.set(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY, account);
		model.addAttribute("payLogList", payLogService.findAll(account.getId()));
		return "home/account/user-account";
	}
	
	/**
	 * 用户充值页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/user-pay-to-account",method=RequestMethod.GET)
	public String userPayToAccount(Model model){
		model.addAttribute("payments", PaymentType.values());
		return "home/account/user-pay-to-account";
	}
	
	/**
	 * 修改个人资料
	 * @param account
	 * @return
	 */
	@RequestMapping(value="/update_info",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> updateInfo(Account account){
		Account loginedAccount = (Account)SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		loginedAccount.setNickname(account.getNickname());

	 * @return
	 */
	@RequestMapping(value="/list")
	public String list(Model model, CinemaHallSession cinemaHallSession, PageBean<CinemaHallSession> pageBean){
		model.addAttribute("pageBean", cinemaHallSessionService.findPage(cinemaHallSession, pageBean));
		model.addAttribute("showDate",cinemaHallSession.getShowDate());
		return "admin/cinema_hall_session/list";
	}
	
	/**
	 * 排片场次添加页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.GET)
	public String add(Model model){
		model.addAttribute("cinemaList", cinemaService.findAll());
		model.addAttribute("movieList", movieService.findAll());
		model.addAttribute("cinemaSessionTypeList", CinemaSessionType.values());
		return "admin/cinema_hall_session/add";
	}
	
	/**
	 * 排片场次编辑页面
	 * @param model
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
		model.addAttribute("cinemaHallSession", cinemaHallSessionService.findById(id));
		model.addAttribute("movieList", movieService.findAll());
		model.addAttribute("cinemaList", cinemaService.findAll());
		model.addAttribute("cinemaSessionTypeList", CinemaSessionType.values());
		return "admin/cinema_hall_session/edit";
	}
	
	/**
	 * 添加排片场次表单提交
	 * @param cinemaHallSession
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> add(CinemaHallSession cinemaHallSession){
		if(cinemaHallSession == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		CodeMsg validate = ValidateEntityUtil.validate(cinemaHallSession);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}

			OrderItem orderItem = new OrderItem();
			orderItem.setCinemaHallSeat(cinemaHallSeat);
			orderItem.setMoney(cinemaHallSession.getNewPrice());
			orderItems.add(orderItem);
		}
		if(!orderService.generateOrder(order, orderItems)){
			return Result.error(CodeMsg.HOME_ADD_ORDER_ERROR);
		}
		log.info("订单已经生成");
		return Result.success(order.getSn());
	}
	
	/**
	 * 订单确认支付页面
	 * @param sn
	 * @param model
	 * @return
	 */
	@RequestMapping(value="order_pay",method=RequestMethod.GET)
	public String orderPay(@RequestParam(name="order_sn",required=true)String sn,Model model){
		Order order = orderService.find(sn);
		if(order == null){
			model.addAttribute("msg", "订单编号不存在!");
			return RuntimeConstant.RUN_ERROR_VIEW;
		}
		if(order.getStatus() != Order.status_unpay){
			model.addAttribute("msg", "订单状态不可支付!");
			return RuntimeConstant.RUN_ERROR_VIEW;
		}
		long passTime = System.currentTimeMillis()/1000 - order.getCreateTime().getTime()/1000;
		if(passTime > orderTimeout){
			model.addAttribute("msg", "订单已超时，不可支付!");
			return RuntimeConstant.RUN_ERROR_VIEW;
		}
		//订单状态都合适
		model.addAttribute("leftTime", orderTimeout - passTime);
		model.addAttribute("order", order);
		model.addAttribute("orderItemList", orderItemService.find(order.getId()));
		return "home/order/pay_order";
	}
	
	/**
	 * 订单支付
	 * @param sn
	 * @return
	 */
	@RequestMapping(value="order_pay",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> orderPay(@RequestParam(name="order_sn",required=true)String sn){
		Order order = orderService.find(sn);
		if(order == null){
			return Result.error(CodeMsg.HOME_ORDER_NO_EXIST);
		}
		if(order.getStatus() != Order.status_unpay){

			//表示是密码登录
			if(StringUtils.isEmpty(password)){
				return Result.error(CodeMsg.ADMIN_PASSWORD_EMPTY);
			}
			account = accountService.find(mobile);
			if(account == null){
				return Result.error(CodeMsg.HOME_ACCOUNT_REGISTER_MOBILE_NO_EXIST);
			}
			//表示一切符合，开始检查密码是否正确
			if(!password.equals(account.getPassword())){
				return Result.error(CodeMsg.HOME_ACCOUNT_LOGIN_PWD_ERROR);
			}
		}
		if(tag == 2){
			//从session中获取短信验证码
			String smsCode = (String)SessionUtil.get("home_login_sms_code");
			if(smsCode == null){
				return Result.error(CodeMsg.SESSION_EXPIRED);
			}
			if(!smsCode.equalsIgnoreCase(checkCode)){
				return Result.error(CodeMsg.SMS_CODE_ERROR);
			}
			//短信验证码正确
			SessionUtil.set("home_login_sms_code", null);
			//检查手机号是否已经注册
			account = accountService.find(mobile);
			if(account == null){
				return Result.error(CodeMsg.HOME_ACCOUNT_REGISTER_MOBILE_NO_EXIST);
			}
		}
		//检查用户状态是否正常
		if(account.getStatus() != Account.account_status_able){
			return Result.error(CodeMsg.HOME_ACCOUNT_STATUS_ERROR);
		}
		SessionUtil.set(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY, account);
		return Result.success(true);
	}
}
package com.demo.common.util;

		model.addAttribute("operatorLogs", operaterLogService.findLastestLog(10));
		model.addAttribute("userTotal", accountService.count());
		model.addAttribute("movieTotal", movieService.count());
		model.addAttribute("cinemaTotal", cinemaService.count());
		model.addAttribute("orderTotal", orderService.count());
		model.addAttribute("cinemaHallSessionTotal", cinemaHallSessionService.count());
		model.addAttribute("payLogTotal", payLogService.count());
		model.addAttribute("paySuccessTotal", payLogService.countPaySuccess());
		model.addAttribute("moneyTotal", movieService.sumTotalMoney());
		model.addAttribute("allPayLogList", payLogService.statsAll(5));
		model.addAttribute("paidPayLogList", payLogService.statsPaid(5));
		model.addAttribute("topMovieList", movieService.findTopMoneyList());
		model.addAttribute("showTipsText", showTipsText);
		model.addAttribute("showTipsUrlText", showTipsUrlText);
		model.addAttribute("showTipsUtl", showTipsUtl);
		model.addAttribute("showTipsBtnText", showTipsBtnText);
		return "admin/system/index";
	}
	
	/**
	 * 注销登录
	 * @return
	 */
	@RequestMapping(value="/logout")
	public String logout(){
		User loginedUser = SessionUtil.getLoginedUser();
		if(loginedUser != null){
			SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, null);
		}
		return "redirect:login";
	}
	
	/**
	 * 无权限提示页面
	 * @return
	 */
	@RequestMapping(value="/no_right")
	public String noRight(){
		return "admin/system/no_right";
	}
	
	/**

/**
 * 公用的上传类
 *
 */
@RequestMapping("/upload")
@Controller
public class UploadController {

    @Value("${movie.upload.photo.sufix}")
    private String uploadPhotoSufix;

    @Value("${movie.upload.photo.maxsize}")
    private long uploadPhotoMaxSize;

    private String uploadPhotoPath = System.getProperty("user.dir") + "/src/main/resources/upload/";

    @Value("${movie.upload.video.sufix}")
    private String uploadVideoSufix;

    @Value("${movie.upload.video.maxsize}")
    private long uploadVideoMaxSize;

    private String uploadVideoPath = System.getProperty("user.dir") + "/src/main/resources/upload/video/";

    private Logger log = LoggerFactory.getLogger(UploadController.class);

    /**
     * 图片统一上传类
     *
     * @param photo
     * @return
     */
    @RequestMapping(value = "/upload_photo", method = RequestMethod.POST)
    @ResponseBody
    public Result<String> uploadPhoto(@RequestParam(name = "photo", required = true) MultipartFile photo) {
        //判断文件类型是否是图片
        String originalFilename = photo.getOriginalFilename();

	 * 添加地域表单提交
	 * @param area
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> add(Area area){
		if(area == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		if(StringUtils.isEmpty(area.getName())){
			return Result.error(CodeMsg.ADMIN_AREA_NAME_EMPTY);
		}
		//判断是否是编辑
		if(area.getId() != null && area.getId() > 0){
			Area findById = areaService.findById(area.getId());
			area.setCreateTime(findById.getCreateTime());
		}
		//表示数据合法，可以保存到数据库
		if(areaService.save(area) == null){
			return Result.error(CodeMsg.ADMIN_AREA_SAVE_ERROR);
		}
		return Result.success(true);
	}
	
	/**
	 * 删除
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/delete",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> delete(@RequestParam(name="id",required=true)Long id){
		try {
			areaService.delete(id);
		} catch (Exception e) {
			return Result.error(CodeMsg.ADMIN_AREA_DELETE_ERROR);
		}
		return Result.success(true);
	}
	
	/**
	 * 根据省份id获取城市列表
	 * @param pid
	 * @return
	 */
	@RequestMapping(value="/get_citys",method=RequestMethod.POST)
	@ResponseBody
	public Result<List<Area>> getCitys(@RequestParam(name="pid",required=true)Long pid){
		return Result.success(areaService.getAllCity(pid));
	}
	
	/**
	 * 根据城市id获取城市区

		model.addAttribute("cinemaHallSeatList", cinemaHallSeatService.findAll(cinemaHallSession.getCinemaHall().getId()));
		model.addAttribute("selectedSeatMax", selectedSeatMax);
		List<Order> findByCinemaHallSession = orderService.findByCinemaHallSession(id);
		model.addAttribute("orderSeatList", JSONArray.toJSONString(orderItemService.findOrderItemSeatIds(findByCinemaHallSession)));
		return "home/movie/select_seat";
	}
	
	/**
	 * 获取指定电影、指定影院、指定时间下的场次
	 * @param model
	 * @param mid
	 * @param cid
	 * @param showDate
	 * @return
	 */
	@RequestMapping("/get_show_session")
	public String getShowSession(Model model,
			@RequestParam(name="mid",required=true) Long mid,
			@RequestParam(name="cid",required=true) Long cid,
			@RequestParam(name="showDate",required=true) String showDate){
		model.addAttribute("cinemaHallSessionList", cinemaHallSessionService.findByMovieIdAndCinemaIdAndShowDate(mid, cid, showDate));
		return "home/movie/get_show_session";
	}
	
	/**
	 * 统计电影上映场次
	 * @param movieId
	 * @return
	 */
	@RequestMapping("/get_show_stats")
	@ResponseBody
	public Result<List<Integer>> getShowStats(@RequestParam(name="mid",required=true) Long movieId) {
		List<Integer> ret = new ArrayList<Integer>();
		List<Integer> showTotal = cinemaHallSessionService.getShowTotal(movieId);
		if(showTotal == null || showTotal.size() <= 0){
			ret.add(0);
			ret.add(0);
			return Result.success(ret);
		}
		ret.add(showTotal.size());//上映的影院数
		//计算场次数
		int totalSession = 0;
		for(int i=0; i< showTotal.size();i++){
			totalSession += Integer.parseInt(showTotal.get(i)+"");
		}
		ret.add(totalSession);
		return Result.success(ret);
	}

/**
 * 电影管理控制器
 *
 */
@RequestMapping("/admin/movie")
@Controller
public class MovieController {

	@Autowired
	private MovieService movieService;
	@Autowired
	private MovieCommentService movieCommentService;
	
	/**
	 * 电影列表页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/list")
	public String list(Model model, Movie movie, PageBean<Movie> pageBean){
		model.addAttribute("pageBean", movieService.findPage(movie, pageBean));
		model.addAttribute("name",movie.getName());
		return "admin/movie/list";
	}
	
	/**
	 * 电影添加页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.GET)
	public String add(Model model){
		model.addAttribute("movieAreaList", MovieArea.values());
		model.addAttribute("movieTypeList", MovieType.values());
		model.addAttribute("movieLangList", MovieLang.values());
		return "admin/movie/add";
	}
	
	/**
	 * 电影编辑页面
	 * @param model
	 * @param id

@RequestMapping("/home/movie")
@Controller
public class HomeMovieController {

	@Autowired
	private MovieService movieService;
	@Autowired
	private MovieCommentService movieCommentService;
	@Autowired
	private NewsService newsService;
	@Autowired
	private CinemaHallSessionService cinemaHallSessionService;
	@Autowired
	private CinemaService cinemaService;
	@Autowired
	private CinemaHallSeatService cinemaHallSeatService;
	@Value("${movie.select.seat.max.num}")
	private Integer selectedSeatMax;//最大选座数
	
	@Autowired
	private OrderService orderService;
	@Autowired
	private OrderItemService orderItemService;
	/**
	 * 电影列表页面
	 * @param model
	 * @return
	 */
	@RequestMapping("/list")
	public String list(Model model,@RequestParam(name="type",defaultValue="0") Integer type){
		model.addAttribute("movieList", type == 0 ? movieService.findShowList() : movieService.findFutureList());
		model.addAttribute("type", type);
		model.addAttribute("topNewsList", newsService.findTop());
		model.addAttribute("topMoneyMovieList", movieService.findTopMoneyList());
		return "home/movie/list";
	}
	
	/**
	 * 电影详情页面
	 * @param model
	 * @param id
	 * @return
	 */
	@RequestMapping("/detail")
	public String detail(Model model,@RequestParam(name="id",required=true) Long id){
		model.addAttribute("movie", movieService.findById(id));
		model.addAttribute("topMovieList", movieService.findTopList(5));
		model.addAttribute("distinctCinemaHallSessionList", cinemaHallSessionService.findDistinctCinemaByMovieId(id));
		model.addAttribute("distinctShowDateCinemaHallSessionList", cinemaHallSessionService.findDistinctShowDateByMovieId(id));
		model.addAttribute("commentList", movieCommentService.findByMovie(id));
		return "home/movie/detail";
	}

	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.GET)
	public String add(Model model){
		model.addAttribute("provinceList", areaService.getAllProvince());
		model.addAttribute("cinemaServiceList", CinemaServices.values());
		return "admin/cinema/add";
	}
	
	/**
	 * 电影院编辑页面
	 * @param model
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String edit(Model model,@RequestParam(name="id",required=true)Long id){
		Cinema cinema = cinemaService.findById(id);
		model.addAttribute("cinema", cinema);
		model.addAttribute("provinceList", areaService.getAllProvince());
		model.addAttribute("cityList", areaService.getAllCity(cinema.getArea().getProvinceId()));
		model.addAttribute("districtList", areaService.getAllDistrict(cinema.getArea().getCityId()));
		model.addAttribute("cinemaServiceList", CinemaServices.values());
		return "admin/cinema/edit";
	}
	
	/**
	 * 添加电影院表单提交
	 * @param cinema
	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> add(Cinema cinema){
		if(cinema == null){
			return Result.error(CodeMsg.DATA_ERROR);
		}
		CodeMsg validate = ValidateEntityUtil.validate(cinema);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		//判断是否是编辑
		if(cinema.getId() != null && cinema.getId() > 0){
			Cinema findById = cinemaService.findById(cinema.getId());
			cinema.setCreateTime(findById.getCreateTime());
			cinema.setRate(findById.getRate());
			cinema.setRateCount(findById.getRateCount());
		}
		if(cinema.getArea() != null){
			Area province = areaService.findById(cinema.getArea().getProvinceId());
			Area city = areaService.findById(cinema.getArea().getCityId());
			String address = "";

		return "home/movie/get_show_session";
	}
	
	/**
	 * 统计电影上映场次
	 * @param movieId
	 * @return
	 */
	@RequestMapping("/get_show_stats")
	@ResponseBody
	public Result<List<Integer>> getShowStats(@RequestParam(name="mid",required=true) Long movieId) {
		List<Integer> ret = new ArrayList<Integer>();
		List<Integer> showTotal = cinemaHallSessionService.getShowTotal(movieId);
		if(showTotal == null || showTotal.size() <= 0){
			ret.add(0);
			ret.add(0);
			return Result.success(ret);
		}
		ret.add(showTotal.size());//上映的影院数
		//计算场次数
		int totalSession = 0;
		for(int i=0; i< showTotal.size();i++){
			totalSession += Integer.parseInt(showTotal.get(i)+"");
		}
		ret.add(totalSession);
		return Result.success(ret);
	}
}
package com.demo.controller.admin;

	@RequestMapping(value="/generate_order",method=RequestMethod.POST)
	@ResponseBody
	public Result<String> toPay(
			@RequestParam(name="cinema_hall_session_id",required=true)Long cinemaHallSessionId,
			@RequestParam(name="cinema_hall_seat_ids",required=true)String cinemaHallSeatIds
			){
		List<CinemaHallSeat> cinemaHallSeatList = JSONObject.parseArray(cinemaHallSeatIds, CinemaHallSeat.class);
		Account account = (Account) SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		CinemaHallSession cinemaHallSession = cinemaHallSessionService.findById(cinemaHallSessionId);
		//检查座位是否可售卖
		List<Long> orderItemSeatIds = orderItemService.findOrderItemSeatIds(orderService.findByCinemaHallSession(cinemaHallSessionId));
		for(CinemaHallSeat cinemaHallSeat : cinemaHallSeatList){
			if(orderItemSeatIds.contains(cinemaHallSeat.getId())){
				//说明该座位状态不可售卖
				return Result.error(CodeMsg.HOME_ADD_ORDER_SEAT_UNABLE);
			}
		}
		//座位检查一切正常
		Order order = new Order();
		order.setAccount(account);
		order.setCinemaHallSession(cinemaHallSession);
		order.setNewMoney(cinemaHallSession.getNewPrice().multiply(new BigDecimal(cinemaHallSeatList.size())));
		order.setOldMoney(cinemaHallSession.getOldPrice().multiply(new BigDecimal(cinemaHallSeatList.size())));
		order.setNum(cinemaHallSeatList.size());
		order.setSn(StringUtil.generateSn());
		//开始组装订单子项
		List<OrderItem> orderItems = new ArrayList<OrderItem>();
		for(CinemaHallSeat cinemaHallSeat : cinemaHallSeatList){
			OrderItem orderItem = new OrderItem();
			orderItem.setCinemaHallSeat(cinemaHallSeat);
			orderItem.setMoney(cinemaHallSession.getNewPrice());
			orderItems.add(orderItem);
		}
		if(!orderService.generateOrder(order, orderItems)){
			return Result.error(CodeMsg.HOME_ADD_ORDER_ERROR);
		}
		log.info("订单已经生成");
		return Result.success(order.getSn());
	}
	
	/**
	 * 订单确认支付页面
	 * @param sn
	 * @param model
	 * @return
	 */
	@RequestMapping(value="order_pay",method=RequestMethod.GET)
	public String orderPay(@RequestParam(name="order_sn",required=true)String sn,Model model){

	 * @return
	 */
	@RequestMapping(value="/add",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> add(Menu menu){
		if(menu == null){
			Result.error(CodeMsg.DATA_ERROR);
		}
		//用统一验证实体方法验证是否合法
		CodeMsg validate = ValidateEntityUtil.validate(menu);
		if(validate.getCode() != CodeMsg.SUCCESS.getCode()){
			return Result.error(validate);
		}
		if(menu.getParent() != null){
			if(menu.getParent().getId() == null){
				menu.setParent(null);
			}
		}
		//表示验证都通过，开始添加数据库
		if(menuService.save(menu) == null){
			Result.error(CodeMsg.ADMIN_MENU_ADD_ERROR);
		}
		//数据库添加操作成功,记录日志
		operaterLogService.add("添加菜单信息【" + menu + "】");
		return Result.success(true);
	}
	
	/**
	 * 菜单编辑页面
	 * @param model
	 * @param id
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.GET)
	public String eidt(Model model,@RequestParam(name="id",required=true)Long id){
		List<Menu> findAll = menuService.findAll();
		model.addAttribute("title","菜单列表");
		model.addAttribute("topMenus",MenuUtil.getTopMenus(findAll));
		model.addAttribute("secondMenus",MenuUtil.getSecondMenus(findAll));
		model.addAttribute("menu",menuService.find(id));
		return "admin/menu/edit";
	}
	
	/**
	 * 菜单编辑页面表单提交处理
	 * @param request
	 * @param menu
	 * @return
	 */
	@RequestMapping(value="/edit",method=RequestMethod.POST)

	private MovieCommentService movieCommentService;
	@Autowired
	private CinemaCommentService cinemaCommentService;
	
	/**
	 * 前台用户中心首页
	 * @param model
	 * @return
	 */
	@RequestMapping("/user-center")
	public String index(Model model){
		Account account = (Account) SessionUtil.get(SessionConstant.SESSION_ACCOUNT_LOGIN_KEY);
		model.addAttribute("orderList", orderService.findAllPaid(account.getId()));
		return "home/account/user-center";
	}
	
	/**
	 * 个人资料页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/user-info",method=RequestMethod.GET)
	public String userInfo(Model model){
		return "home/account/user-info";
	}
	
	/**
	 * 修改密码页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/update-pwd",method=RequestMethod.GET)
	public String updatePwd(Model model){
		return "home/account/update-pwd";
	}
	
	/**
	 * 修改头像页面
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/update-head-pic",method=RequestMethod.GET)
	public String updateHeadPic(Model model){
		return "home/account/update-head-pic";
	}
	
	/**
	 * 账户余额
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/user-account",method=RequestMethod.GET)
	public String userAccount(Model model){

	@ResponseBody
	public Result<Boolean> updatePwd(@RequestParam(name="oldPwd",required=true)String oldPwd,
			@RequestParam(name="newPwd",required=true)String newPwd
			){
		User loginedUser = SessionUtil.getLoginedUser();
		if(!loginedUser.getPassword().equals(oldPwd)){
			return Result.error(CodeMsg.ADMIN_USER_UPDATE_PWD_ERROR);
		}
		if(StringUtils.isEmpty(newPwd)){
			return Result.error(CodeMsg.ADMIN_USER_UPDATE_PWD_EMPTY);
		}
		loginedUser.setPassword(newPwd);
		//保存数据库
		userService.save(loginedUser);
		//更新session
		SessionUtil.set(SessionConstant.SESSION_USER_LOGIN_KEY, loginedUser);
		return Result.success(true);
	}
	
	/**
	 * 日志管理列表
	 * @param model
	 * @param operaterLog
	 * @param pageBean
	 * @return
	 */
	@RequestMapping(value="/operator_log_list")
	public String operatorLogList(Model model, OperaterLog operaterLog, PageBean<OperaterLog> pageBean){
		model.addAttribute("pageBean", operaterLogService.findList(operaterLog, pageBean));
		model.addAttribute("operator", operaterLog.getOperator());
		model.addAttribute("title", "日志列表");
		return "admin/system/operator_log_list";
	}
	
	/**
	 * 删除操作日志，可删除多个
	 * @param ids
	 * @return
	 */
	@RequestMapping(value="/delete_operator_log",method=RequestMethod.POST)
	@ResponseBody
	public Result<Boolean> delete(String ids){
		if(!StringUtils.isEmpty(ids)){
			String[] splitIds = ids.split(",");
			for(String id : splitIds){
				operaterLogService.delete(Long.valueOf(id));
			}
		}
		return Result.success(true);
	}