基于javaweb+mysql的springboot房屋租赁管理系统(java+springboot+vue+maven+mysql)

基于javaweb+mysql的springboot房屋租赁管理系统(java+springboot+vue+maven+mysql)

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb+mysql的SpringBoot房屋租赁管理系统(java+springboot+vue+maven+mysql)

用户类型：管理员、房主、用户

一、项目运行 环境配置：

Jdk1.8 + Tomcat8.5 + Mysql + HBuilderX（Webstorm也行）+ Eclispe（IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持）。

项目技术：

Spring + SpringBoot+ mybatis + Maven + Vue 等等组成，B/S模式 + Maven管理等等。

        return Result.error("-1", "确认失败");
    }

    @PostMapping("/cancelAppoint")
    @ApiOperation("取消预约")
    @ApiImplicitParam(name = "apId", value = "预约记录的id")
    public Result<?> cancelAppoint(Long apId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 取消预约记录
        int result = houseService.cancelAppoint(apId, uId, "merchant");
        // 删除预设未签订的合约
        int result2 = houseService.deleteContract(apId);
        if (result < 1) {
            return Result.error("-1", "取消失败");
        }
        if (result2 < 1) {
            System.out.println("预设的合同删除失败（取消预约联动删除预设合同）");
        }

        return Result.success("取消成功");
    }

    @GetMapping("/getUnconfirmedContract")
    @ApiOperation("获取未确认的租房合同")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getUnconfirmedContract(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getUnconfirmedContract(new Page<RentHouseContract>(pageNum, pageSize), uId);

        return Result.success(page);
    }

    @PostMapping("/confirmRentHouse")
    @ApiOperation("确认租房")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "rhcId", value = "租房合约的id"),
            @ApiImplicitParam(name = "startDate", value = "租约起始日期"),
            @ApiImplicitParam(name = "endDate", value = "终止日期"),
            @ApiImplicitParam(name = "roomNum", value = "房间号")})
    public Result<?> confirmRentHouse(@RequestParam("rhcId") Long rhcId,
                                      @RequestParam("startDate") String apStartDate,
                                      @RequestParam("endDate") String apEndDate,
                                      @RequestParam("roomNum") String roomNum,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

            return Result.success();
        }

        return Result.error("-1", result);
    }

    @GetMapping("/getMyBasicHouseImfor")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("获取当前用户发布的房源(简要信息)")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),
            @ApiImplicitParam(name = "titleKeyword", value = "标题关键字"),})
    public Result<?> getBasicHouseImfor(@RequestParam(defaultValue = "1") Integer pageNum,
                                        @RequestParam(defaultValue = "10") Integer pageSize,
                                        @RequestParam(name = "titleKeyword", defaultValue = "") String titleKeyword,
                                        HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<House> resultPage =
                houseService.getMyBasicHouseImfor(new Page<House>(pageNum, pageSize), titleKeyword, uId);

        return Result.success(resultPage);
    }

    @GetMapping("/getImageById")
    @ApiOperation("根据图片id获取图片url")
    @ApiImplicitParam(name = "hiId", value = "图片id")
    public Result<?> getBasicHouseImfor(@RequestParam("hiId") Long hiId){
        String url = houseService.getImageByHiId(hiId);
        return Result.success(url);
    }

    @GetMapping("/getAppointRecord")
    @ApiOperation("获取被预约的记录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getAppointRecord(@RequestParam(defaultValue = "1") Integer pageNum,
                                        @RequestParam(defaultValue = "10") Integer pageSize,
                                        HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<AppointRecord> page = houseService.getAppointRecord(new Page<AppointRecord>(pageNum, pageSize), uId, "leaser");

            String day = String.format("%td", rhc.getApStartDate());
            rhc.setApPayDate(day);
        } catch (ParseException e) {
            e.printStackTrace();
            return Result.error("-1", "时间格式出错");
        }
        int update = houseService.confirmRentHouse(rhc, uId);
        if (update == 1){
            return Result.success();
        }

        return Result.error("-1", "确认失败");
    }

    @GetMapping("/getConfirmRentHouseContact")
    @ApiOperation("获取已租的合同信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getConfirmRentHouseContact(@RequestParam(defaultValue = "1") Integer pageNum,
                                            @RequestParam(defaultValue = "10") Integer pageSize,
                                            HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getConfirmRentHouseContact(new Page<RentHouseContract>(pageNum, pageSize), uId);
        // 查询该合同当月的账单状态
        payAndBillService.setCurrentBillState(page.getRecords());

        return Result.success(page);
    }

    @PostMapping("/inputBill")
    @ApiOperation("录入账单")
    public Result<?> inputBill(InputBillVo inputBillVo, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = payAndBillService.inputBill(inputBillVo, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "录入失败");
    }

    @PostMapping("/terminateContract")
    @ApiOperation("终止合同")
    @ApiImplicitParam(name = "rhcId", value = "合同的id")

@RestController
@RequestMapping("/merchant")
@Api(tags = "商家对房源的相关操作")
public class MerchantOperationHouseController {
    @Autowired
    HouseService houseService;
    @Autowired
    PayAndBillService payAndBillService;

    @PostMapping("/addHouse")
    @ApiOperation("新增房源")
    public Result<?> addHouse(HouseCreateVo houseCreateVo,
                              HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String dateNowStr = sdf.format(new Date());

        houseCreateVo.transitionFloorStrToNum();
        houseCreateVo.sethUidForeign(uId);
        houseCreateVo.sethCheckinTime(dateNowStr);
        String result = houseService.addHouse(houseCreateVo, uId);
        if (result.equals("保存失败")){
            return Result.error("-1", result);
        }

        return Result.success(result);
    }

    /*
    * ============== 修改房源信息 start =======================
    * */
    @PostMapping("/removeOneHouseImage")
    @ApiOperation("移除一张房源的图片")
    @ApiImplicitParam(name = "imageId", value = "需要删除的这张房源图片id")
    public Result<?> removeOneHouseImage(@RequestParam("imageId") Long imageId){
        String result = houseService.removeOneHouseImage(imageId);
        if (result.equals("删除成功")){
            return Result.success();
        }

        return Result.error("-1", result);
    }

    @PostMapping("/updateHouse")
    @ApiOperation( tags = "更新房源", value = "更新房源+新增的图片+配套设备")
    public Result<?> updateHouse(HouseCreateVo houseCreateVo,
                              HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

    public Result<?> getConfirmRentHouseContact(@RequestParam(defaultValue = "1") Integer pageNum,
                                            @RequestParam(defaultValue = "10") Integer pageSize,
                                            HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getConfirmRentHouseContact(new Page<RentHouseContract>(pageNum, pageSize), uId);
        // 查询该合同当月的账单状态
        payAndBillService.setCurrentBillState(page.getRecords());

        return Result.success(page);
    }

    @PostMapping("/inputBill")
    @ApiOperation("录入账单")
    public Result<?> inputBill(InputBillVo inputBillVo, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = payAndBillService.inputBill(inputBillVo, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "录入失败");
    }

    @PostMapping("/terminateContract")
    @ApiOperation("终止合同")
    @ApiImplicitParam(name = "rhcId", value = "合同的id")
    public Result<?> terminateContract(@RequestParam("rhcId") Long rhcId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = houseService.terminateContract(rhcId, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "终止失败");
    }

    @GetMapping("/getHistoryBill")
    @ApiOperation("获取我的历史账单(商家)")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "search", value = "搜索的关键字"),
            @ApiImplicitParam(name = "type", value = "根据哪种类型搜索（价格，房间号，地址）"),
            @ApiImplicitParam(name = "pageNum", value = "当前页数"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getHistoryBill(@RequestParam(value = "search", defaultValue = "") String search,

        logger.info("请求方法 : " + request.getMethod());
        logger.info("传入参数 :{} ", proceedingJoinPoint.getArgs());
        // 获取方法的返回结果
        Object result = proceedingJoinPoint.proceed();
        logger.info("返回数据:{}", JSON.toJSONString(result));
        return result;
    }

    @AfterThrowing(value = "LogPointcut()", throwing = "e")
    public void doThrow(JoinPoint joinPoint, Exception e) {
        Signature signature = joinPoint.getSignature();
        String name = signature.getName();
        logger.info("异常信息：{}:{}", name, e.getMessage());
    }
}
package com.like.filter;

/**
 * 描述：异常拦截类
 *
 */
@ControllerAdvice
public class NoPermissionException {
    @ResponseBody
    @ExceptionHandler(UnauthorizedException.class)
    public String handleShiroException(Exception ex) {
        //自定义的记录日志方法

        return "无权限访问";
    }

    @ResponseBody
    @ExceptionHandler(AuthorizationException.class)
    public String AuthorizationException(Exception ex) {

        // 查询用户名是否被占用
        User user = userService.getAccountByName(username);
        if (user == null) {
            // 注册账号
            // 使用MD5+Salt（盐--用户名）+2次散列
            String newPassword = new SimpleHash("MD5", password, username, 2).toHex();
            newPassword=password;
            int state = userService.addAccount(username, newPassword);
            if (state == 1) {
                return Result.success();
            }
            else {
                return Result.error("-1", "注册失败，未知错误");
            }
        }

        return Result.error("-1", "用户名已被占用，换一个试试");
    }

    @GetMapping("/notRole")
    @ApiOperation("无权限跳转的接口")
    public Result<?> notRole() {
        System.out.println("来到notRole");
        return Result.error("403", "没有权限访问...");
    }

    @GetMapping("/logout")
    @ApiOperation("执行登出后，返回登出成功json信息")
    public Result<?> logout() {
        // 从SecurityUtils里边创建一个 subject
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        System.out.println("==========logout登出系统============");

        return Result.success("登出系统");
    }

    /**
     * 登录接口
     * */

        // 保存图片+添加记录到申请表
        boolean state = userService.merchantApply(files, uId);
        if (state){
            return Result.success();
        }
        return Result.error("-1", "上传失败");
    }

    @PostMapping("/complaint")
    @ApiOperation("投诉房源或用户")
    @ApiImplicitParam(name = "complaintVo", value = "投诉信息的封装")
    public Result<?> complaint(ComplaintVo complaintVo,
                               HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        boolean state = false;

        if (complaintVo.getType().equals("house"))
            // 投诉房源
            state = complaintService.complaintHouse(complaintVo, uId);
        else
            // 投诉用户
            state = complaintService.complaintUser(complaintVo, uId);

        if (state)
            return Result.success();

        return Result.error("-1", "未知错误");
    }
}
package com.like.common;

/*
* 日志的AOP
* */
@Aspect
@Component

            @ApiImplicitParam(name = "pageNum", value = "当前页数"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getHistoryBill(@RequestParam(value = "search", defaultValue = "") String search,
                                    @RequestParam(value = "type", defaultValue = "") String type,
                                    @RequestParam(value = "pageNum", defaultValue = "1") Integer pageNum,
                                    @RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize,
                                    HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        String price = "";
        String address = "";
        String roomNum = "";

        if (type.equals("price")) {
            String regEx = "[^0-9]";
            Pattern pattern = Pattern.compile(regEx);
            Matcher matcher;
            // 将价格的非数字字符去除
            matcher = pattern.matcher(search);
            price = matcher.replaceAll("").trim();
        }
        else if (type.equals("address")){
            address = search;
        }
        else if (type.equals("roomNum")){
            roomNum = search;
        }

        Page<HistoryBill> resultPage = payAndBillService.getHistoryBillByUId("merchant", new Page<HistoryBill>(pageNum, pageSize), uId, price, address, roomNum);
        return Result.success(resultPage);
    }
}
package com.like.controller;

/**
 * 登录和权限相关的接口
 * */
@RestController
@Api(tags = {"登录和注册"})
public class LoginRegisterController {
    @Autowired
    UserService userService;

    /*登录
    * 自己设置默认rememberMe登录状态true
    * 自定义有效期7天 --cookie在ShiroLoginFilter中有设置了
    *                --Session在ShiroLoginFilter中有设置了
    * */
    @RequestMapping(value = "/login", method = RequestMethod.POST)
    @ResponseBody
    public Result<?> login(@RequestParam("username") String username,
                           @RequestParam("password") String password,
                           @RequestParam(defaultValue = "true") Boolean rememberMe) {
        Subject subject = SecurityUtils.getSubject();
        // 在认证提交前准备 token（令牌）
        System.out.println(rememberMe + "======================");
        UsernamePasswordToken token = new UsernamePasswordToken(username, password, rememberMe);
        // 执行认证登陆
        try {
            subject.login(token);
        } catch (UnknownAccountException uae) {
            return Result.error("-1", "未知账户");
        } catch (IncorrectCredentialsException ice) {

@RestController
@RequestMapping("/admin")
@Api(tags = "管理员对系统管理的相关操作")
public class AdminOperationController {
    @Autowired
    MateRuleAction mateRuleAction;
    @Autowired
    AdminService adminService;
    @Autowired
    UserService userService;
    @Autowired
    HouseService houseService;

    @GetMapping("/getMerchantApply")
    @ApiOperation("获取商家申请未处理的记录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getMerchantApply(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<LeaserApply> page = adminService.getMerchantApply(new Page<LeaserApply>(pageNum, pageSize), uId);

        return Result.success(page);
    }

    @PostMapping("/updateLeaserApply")
    @ApiOperation("更新房主申请的记录状态")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "leaserApplyId", value = "申请记录的id"),

    @ApiImplicitParams({
            @ApiImplicitParam(name = "username", value = "账号"),
            @ApiImplicitParam(name = "password", value = "密码")})
    public Result<?> register(@RequestParam("username") String username, @RequestParam("password") String password) {

        // 查询用户名是否被占用
        User user = userService.getAccountByName(username);
        if (user == null) {
            // 注册账号
            // 使用MD5+Salt（盐--用户名）+2次散列
            String newPassword = new SimpleHash("MD5", password, username, 2).toHex();
            newPassword=password;
            int state = userService.addAccount(username, newPassword);
            if (state == 1) {
                return Result.success();
            }
            else {
                return Result.error("-1", "注册失败，未知错误");
            }
        }

        return Result.error("-1", "用户名已被占用，换一个试试");
    }

    @GetMapping("/notRole")
    @ApiOperation("无权限跳转的接口")
    public Result<?> notRole() {
        System.out.println("来到notRole");
        return Result.error("403", "没有权限访问...");
    }

    @GetMapping("/logout")
    @ApiOperation("执行登出后，返回登出成功json信息")
    public Result<?> logout() {
        // 从SecurityUtils里边创建一个 subject
        Subject subject = SecurityUtils.getSubject();
        subject.logout();
        System.out.println("==========logout登出系统============");

        return Result.success("登出系统");
    }

    /**
     * 登录接口

        payAndBillService.setCurrentBillState(page.getRecords());

        return Result.success(page);
    }

    @PostMapping("/inputBill")
    @ApiOperation("录入账单")
    public Result<?> inputBill(InputBillVo inputBillVo, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = payAndBillService.inputBill(inputBillVo, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "录入失败");
    }

    @PostMapping("/terminateContract")
    @ApiOperation("终止合同")
    @ApiImplicitParam(name = "rhcId", value = "合同的id")
    public Result<?> terminateContract(@RequestParam("rhcId") Long rhcId, HttpServletRequest request) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        int insert = houseService.terminateContract(rhcId, uId);
        if (insert == 1){
            return Result.success();
        }

        return Result.error("-1", "终止失败");
    }

    @GetMapping("/getHistoryBill")
    @ApiOperation("获取我的历史账单(商家)")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "search", value = "搜索的关键字"),
            @ApiImplicitParam(name = "type", value = "根据哪种类型搜索（价格，房间号，地址）"),
            @ApiImplicitParam(name = "pageNum", value = "当前页数"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getHistoryBill(@RequestParam(value = "search", defaultValue = "") String search,
                                    @RequestParam(value = "type", defaultValue = "") String type,
                                    @RequestParam(value = "pageNum", defaultValue = "1") Integer pageNum,
                                    @RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize,
                                    HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        String price = "";
        String address = "";
        String roomNum = "";

        if (type.equals("price")) {
            String regEx = "[^0-9]";
            Pattern pattern = Pattern.compile(regEx);
            Matcher matcher;
            // 将价格的非数字字符去除

        String dateNowStr = sdf.format(new Date());

        houseCreateVo.transitionFloorStrToNum();
        houseCreateVo.sethUidForeign(uId);
        houseCreateVo.sethCheckinTime(dateNowStr);
        String result = houseService.addHouse(houseCreateVo, uId);
        if (result.equals("保存失败")){
            return Result.error("-1", result);
        }

        return Result.success(result);
    }

    /*
    * ============== 修改房源信息 start =======================
    * */
    @PostMapping("/removeOneHouseImage")
    @ApiOperation("移除一张房源的图片")
    @ApiImplicitParam(name = "imageId", value = "需要删除的这张房源图片id")
    public Result<?> removeOneHouseImage(@RequestParam("imageId") Long imageId){
        String result = houseService.removeOneHouseImage(imageId);
        if (result.equals("删除成功")){
            return Result.success();
        }

        return Result.error("-1", result);
    }

    @PostMapping("/updateHouse")
    @ApiOperation( tags = "更新房源", value = "更新房源+新增的图片+配套设备")
    public Result<?> updateHouse(HouseCreateVo houseCreateVo,
                              HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String dateNowStr = sdf.format(new Date());

        houseCreateVo.sethCheckinTime(dateNowStr);
        houseCreateVo.transitionFloorStrToNum();
        String result = houseService.updateHouse(houseCreateVo, uId);
        if (result.equals("更新成功")){

    /**
     * 在访问controller前判断是否登录，返回json，不进行重定向。
     * @param request
     * @param response
     * @return true-继续往下执行，false-该filter过滤器已经处理，不继续执行其他过滤器
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");
        httpServletResponse.getWriter().write(JSONObject.toJSON(Result.error("401","登录认证失效，请重新登录!")).toString());

        return false;
    }

    @Override
    protected boolean onLoginSuccess(AuthenticationToken token, Subject subject, ServletRequest request, ServletResponse response) throws Exception {
        WebUtils.getAndClearSavedRequest(request);
        // 登录成功之后 设置session时间为7天 单位为毫秒
        SecurityUtils.getSubject().getSession().setTimeout(7 * 24 * 60 * 60 * 1000L);
        return true;
    }
}
package com.like.controller;

@RestController
public class MessageController {
    @Autowired
    MessageService messageService;

    @GetMapping("/getMateRuleAndHouseImfor")
    @ApiOperation("获取征集房源规则和当前规则匹配到的房源")
    public Result<?> getMateRuleAndHouseImfor(HttpServletRequest request) {
        // 从token中获取出用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        // 获取当前用户最新的匹配规则 和 当前规则匹配成功的房源
        MateRuleAndRecordVo marVo = mateRuleService.getRuleAndHouseImfor(uId);

        if (marVo == null) {
            return Result.success("noMateRule");
        }
        return Result.success(marVo);
    }

    @PostMapping("/addMateRule")
    @ApiOperation("新建规则征集房源")
    public Result<?> addMateRule(@RequestBody MateRuleVo mateRuleVo) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        if (mateRuleVo.getProvinceValue() != null) {
            // 将前端选择的户型多选 合并为一个字符串使用#进行间隔
            mateRuleVo.transitionToStringHouseType();

            // 新增匹配规则
            int addResult = mateRuleService.addMateRule(mateRuleVo, uId);
            // 启动匹配
            int startResult = mateRuleService.startMateRule(mateRuleVo.getMrId(), uId);
            if (addResult != 1) {
                return Result.error("-1", "创建失败");
            } else if (startResult != 1) {
                return Result.error("-1", "启动失败");
            }

            return Result.success("");
        }

        return Result.error("-1", "必须输入规则");
    }

    @PostMapping("/updateMateRule")
    @ApiOperation("修改规则征集房源")
    public Result<?> updateMateRule(@RequestBody MateRuleVo mateRuleVo) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        if (mateRuleVo.getMrId() != null) {
            // 将前端选择的户型多选 合并为一个字符串使用#进行间隔
            mateRuleVo.transitionToStringHouseType();
            // 修改匹配规则

        }

        return Result.error("-1", state);
    }

    @GetMapping("/appointRecord")
    @ApiOperation("我的预约记录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> appointRecord(@RequestParam(defaultValue = "1") Integer pageNum,
                                   @RequestParam(defaultValue = "1000") Integer pageSize,
                                   HttpServletRequest request) {
        // 从token中获取出用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<AppointRecord> page = houseService.getAppointRecord(new Page<AppointRecord>(pageNum, pageSize), uId, "tenant");
        List<AppointRecord> appointRecords = page.getRecords();

        return Result.success(appointRecords);
    }

    @GetMapping("/cancelAppoint")
    @ApiOperation("取消预约")
    @ApiImplicitParam(name = "apId", value = "预约记录的id")
    public Result<?> cancelAppoint(@RequestParam("apId") Long apId,
                                   HttpServletRequest request) {
        // 从token中获取出用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 取消预约记录
        int result = houseService.cancelAppoint(apId, uId, "user");
        // 删除预设未签订的合约
        int result2 = houseService.deleteContract(apId);
        if (result < 1) {
            return Result.error("-1", "取消失败");
        }
        if (result2 < 1) {
            System.out.println("预设的合同删除失败（取消预约联动删除预设合同）");
        }

        return Result.success("取消成功");
    }

    @GetMapping("/getMateRuleAndHouseImfor")
    @ApiOperation("获取征集房源规则和当前规则匹配到的房源")
    public Result<?> getMateRuleAndHouseImfor(HttpServletRequest request) {
        // 从token中获取出用户id

    @GetMapping("/cancelAppoint")
    @ApiOperation("取消预约")
    @ApiImplicitParam(name = "apId", value = "预约记录的id")
    public Result<?> cancelAppoint(@RequestParam("apId") Long apId,
                                   HttpServletRequest request) {
        // 从token中获取出用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 取消预约记录
        int result = houseService.cancelAppoint(apId, uId, "user");
        // 删除预设未签订的合约
        int result2 = houseService.deleteContract(apId);
        if (result < 1) {
            return Result.error("-1", "取消失败");
        }
        if (result2 < 1) {
            System.out.println("预设的合同删除失败（取消预约联动删除预设合同）");
        }

        return Result.success("取消成功");
    }

    @GetMapping("/getMateRuleAndHouseImfor")
    @ApiOperation("获取征集房源规则和当前规则匹配到的房源")
    public Result<?> getMateRuleAndHouseImfor(HttpServletRequest request) {
        // 从token中获取出用户id
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        // 获取当前用户最新的匹配规则 和 当前规则匹配成功的房源
        MateRuleAndRecordVo marVo = mateRuleService.getRuleAndHouseImfor(uId);

        if (marVo == null) {
            return Result.success("noMateRule");
        }
        return Result.success(marVo);
    }

    @PostMapping("/addMateRule")
    @ApiOperation("新建规则征集房源")
    public Result<?> addMateRule(@RequestBody MateRuleVo mateRuleVo) {
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        if (mateRuleVo.getProvinceValue() != null) {
            // 将前端选择的户型多选 合并为一个字符串使用#进行间隔
            mateRuleVo.transitionToStringHouseType();

            // 新增匹配规则
            int addResult = mateRuleService.addMateRule(mateRuleVo, uId);
            // 启动匹配
            int startResult = mateRuleService.startMateRule(mateRuleVo.getMrId(), uId);

    @ApiOperation( tags = "更新房源", value = "更新房源+新增的图片+配套设备")
    public Result<?> updateHouse(HouseCreateVo houseCreateVo,
                              HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        String dateNowStr = sdf.format(new Date());

        houseCreateVo.sethCheckinTime(dateNowStr);
        houseCreateVo.transitionFloorStrToNum();
        String result = houseService.updateHouse(houseCreateVo, uId);
        if (result.equals("更新成功")){
            return Result.success(result);
        }

        return Result.error("-1", result);
    }
    /* ============== end ======================= */

    @PostMapping("/deleteHouse")
    @ApiOperation("删除房源")
    @ApiImplicitParam(name = "hId", value = "房源id")
    public Result<?> deleteHouse(@RequestParam("hId") Long hId,
                                 HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();

        String result = houseService.deleteHouse(hId, uId);
        if (result.equals("删除成功")){
            return Result.success();
        }

        return Result.error("-1", result);
    }

    @GetMapping("/getMyBasicHouseImfor")
    //方法参数说明，name参数名；value参数说明，备注；dataType参数类型；required 是否必传；defaultValue 默认值
    @ApiOperation("获取当前用户发布的房源(简要信息)")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),
            @ApiImplicitParam(name = "titleKeyword", value = "标题关键字"),})
    public Result<?> getBasicHouseImfor(@RequestParam(defaultValue = "1") Integer pageNum,
                                        @RequestParam(defaultValue = "10") Integer pageSize,
                                        @RequestParam(name = "titleKeyword", defaultValue = "") String titleKeyword,
                                        HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<House> resultPage =

/*
* 自定义Shiro的登录过滤器
* 问题1：前后端分离，跨域访问
* 解决：未如果未登录，shiro默认重定向出错
*       改为返回JSON，在shiro配置类的过滤工厂中添加配置
* 问题2：重写了登录过滤器，如果使用rememberMe就要在isAccessAllowed中把记住登录的这种也考虑为登录（user级别的）
* */
public class ShiroLoginFilter extends FormAuthenticationFilter {

    /**
     * 这个方法决定了是否能让用户登录
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        Subject subject = getSubject(request, response);

        //如果 isAuthenticated 为 false 证明不是登录过的，同时 isRememberd 为true 证明是没登陆直接通过记住我功能进来的
        if(!subject.isAuthenticated() && subject.isRemembered()){

            //获取session看看是不是空的
            Session session = subject.getSession(true);

            //随便拿session的一个属性来看session当前是否是空的，我用userId，你们的项目可以自行发挥
            /*if(session.getAttribute("userId") == null){

                //如果是空的才初始化，否则每次都要初始化，项目得慢死
                //这边根据前面的前提假设，拿到的是username
                String username = subject.getPrincipal().toString();

                //在这个方法里面做初始化用户上下文的事情，比如通过查询数据库来设置session值，你们自己发挥
                globalUserService.initUserContext(username, subject);
            }*/
        }

        //这个方法本来只返回 subject.isAuthenticated() 现在我们加上 subject.isRemembered() 让它同时也兼容remember这种情况
        return subject.isAuthenticated() || subject.isRemembered();
    }

    /**
     * 在访问controller前判断是否登录，返回json，不进行重定向。
     * @param request
     * @param response
     * @return true-继续往下执行，false-该filter过滤器已经处理，不继续执行其他过滤器
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");
        httpServletResponse.getWriter().write(JSONObject.toJSON(Result.error("401","登录认证失效，请重新登录!")).toString());

/*
* 自定义Shiro的登录过滤器
* 问题1：前后端分离，跨域访问
* 解决：未如果未登录，shiro默认重定向出错
*       改为返回JSON，在shiro配置类的过滤工厂中添加配置
* 问题2：重写了登录过滤器，如果使用rememberMe就要在isAccessAllowed中把记住登录的这种也考虑为登录（user级别的）
* */
public class ShiroLoginFilter extends FormAuthenticationFilter {

    /**
     * 这个方法决定了是否能让用户登录
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        Subject subject = getSubject(request, response);

        //如果 isAuthenticated 为 false 证明不是登录过的，同时 isRememberd 为true 证明是没登陆直接通过记住我功能进来的
        if(!subject.isAuthenticated() && subject.isRemembered()){

            //获取session看看是不是空的
            Session session = subject.getSession(true);

            //随便拿session的一个属性来看session当前是否是空的，我用userId，你们的项目可以自行发挥
            /*if(session.getAttribute("userId") == null){

                //如果是空的才初始化，否则每次都要初始化，项目得慢死
                //这边根据前面的前提假设，拿到的是username
                String username = subject.getPrincipal().toString();

                //在这个方法里面做初始化用户上下文的事情，比如通过查询数据库来设置session值，你们自己发挥
                globalUserService.initUserContext(username, subject);
            }*/
        }

        //这个方法本来只返回 subject.isAuthenticated() 现在我们加上 subject.isRemembered() 让它同时也兼容remember这种情况
        return subject.isAuthenticated() || subject.isRemembered();
    }

    /**
     * 在访问controller前判断是否登录，返回json，不进行重定向。
     * @param request
     * @param response
     * @return true-继续往下执行，false-该filter过滤器已经处理，不继续执行其他过滤器
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws IOException {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setCharacterEncoding("UTF-8");
        httpServletResponse.setContentType("application/json");

        return Result.success(page);
    }

    @PostMapping("/confirmRentHouse")
    @ApiOperation("确认租房")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "rhcId", value = "租房合约的id"),
            @ApiImplicitParam(name = "startDate", value = "租约起始日期"),
            @ApiImplicitParam(name = "endDate", value = "终止日期"),
            @ApiImplicitParam(name = "roomNum", value = "房间号")})
    public Result<?> confirmRentHouse(@RequestParam("rhcId") Long rhcId,
                                      @RequestParam("startDate") String apStartDate,
                                      @RequestParam("endDate") String apEndDate,
                                      @RequestParam("roomNum") String roomNum,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        RentHouseContract rhc = new RentHouseContract();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        /*System.out.println(apStartDate);
        System.out.println(apEndDate);*/
        try {
            rhc.setRhcId(rhcId);
            rhc.setRhcRomNum(roomNum);
            rhc.setApStartDate(sdf.parse(apStartDate));
            rhc.setApEndDate(sdf.parse(apEndDate));
            rhc.setApLeaseState("正常");
            // 设置每月的支付日
            // 获取今天几号
            String day = String.format("%td", rhc.getApStartDate());
            rhc.setApPayDate(day);
        } catch (ParseException e) {
            e.printStackTrace();
            return Result.error("-1", "时间格式出错");
        }
        int update = houseService.confirmRentHouse(rhc, uId);
        if (update == 1){
            return Result.success();
        }

        return Result.error("-1", "确认失败");
    }

    @GetMapping("/getConfirmRentHouseContact")
    @ApiOperation("获取已租的合同信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getConfirmRentHouseContact(@RequestParam(defaultValue = "1") Integer pageNum,
                                            @RequestParam(defaultValue = "10") Integer pageSize,

        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        // 取消预约记录
        int result = houseService.cancelAppoint(apId, uId, "merchant");
        // 删除预设未签订的合约
        int result2 = houseService.deleteContract(apId);
        if (result < 1) {
            return Result.error("-1", "取消失败");
        }
        if (result2 < 1) {
            System.out.println("预设的合同删除失败（取消预约联动删除预设合同）");
        }

        return Result.success("取消成功");
    }

    @GetMapping("/getUnconfirmedContract")
    @ApiOperation("获取未确认的租房合同")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "pageNum", value = "显示的起始页"),
            @ApiImplicitParam(name = "pageSize", value = "每页的条数"),})
    public Result<?> getUnconfirmedContract(@RequestParam(defaultValue = "1") Integer pageNum,
                                      @RequestParam(defaultValue = "10") Integer pageSize,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        Page<RentHouseContract> page = houseService.getUnconfirmedContract(new Page<RentHouseContract>(pageNum, pageSize), uId);

        return Result.success(page);
    }

    @PostMapping("/confirmRentHouse")
    @ApiOperation("确认租房")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "rhcId", value = "租房合约的id"),
            @ApiImplicitParam(name = "startDate", value = "租约起始日期"),
            @ApiImplicitParam(name = "endDate", value = "终止日期"),
            @ApiImplicitParam(name = "roomNum", value = "房间号")})
    public Result<?> confirmRentHouse(@RequestParam("rhcId") Long rhcId,
                                      @RequestParam("startDate") String apStartDate,
                                      @RequestParam("endDate") String apEndDate,
                                      @RequestParam("roomNum") String roomNum,
                                      HttpServletRequest request){
        Long uId = (Long) SecurityUtils.getSubject().getPrincipal();
        RentHouseContract rhc = new RentHouseContract();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        /*System.out.println(apStartDate);
        System.out.println(apEndDate);*/
        try {
            rhc.setRhcId(rhcId);
            rhc.setRhcRomNum(roomNum);
            rhc.setApStartDate(sdf.parse(apStartDate));

    /**
     * 注册接口
     * */
    @PostMapping("/register")
    @ApiOperation("注册接口")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "username", value = "账号"),
            @ApiImplicitParam(name = "password", value = "密码")})
    public Result<?> register(@RequestParam("username") String username, @RequestParam("password") String password) {

        // 查询用户名是否被占用
        User user = userService.getAccountByName(username);
        if (user == null) {
            // 注册账号
            // 使用MD5+Salt（盐--用户名）+2次散列
            String newPassword = new SimpleHash("MD5", password, username, 2).toHex();
            newPassword=password;
            int state = userService.addAccount(username, newPassword);
            if (state == 1) {
                return Result.success();
            }
            else {
                return Result.error("-1", "注册失败，未知错误");
            }
        }

        return Result.error("-1", "用户名已被占用，换一个试试");
    }

    @GetMapping("/notRole")
    @ApiOperation("无权限跳转的接口")
    public Result<?> notRole() {

    @PostMapping("/passComplaint")
    @ApiOperation("投诉信息--审核通过（投诉房源、用户）")
    @ApiImplicitParams({@ApiImplicitParam(name = "comeFromUId", value = "该投诉的发起者用户id"),
            @ApiImplicitParam(name = "type", value = "类型（house、user）"),
            @ApiImplicitParam(name = "id", value = "投诉记录的id"),
            @ApiImplicitParam(name = "punishType", value = "处罚的类型"),})
    public Result<?> passComplaint(@RequestParam("type") String type,
                                      @RequestParam("id") Long id,
                                      @RequestParam("comeFromUId") Long comeFromUId,
                                      @RequestParam("punishType") String punishType) {
        // 更新投诉记录的状态
        int update = adminService.complaintSuccess(type, id);
        if (update == 1) {
            return Result.success();
        }
        return Result.error("-1", "操作失败");
    }

    @GetMapping("/manualStartMatchHouse")
    @ApiOperation("人工启动匹配房源程序接口")
    public Result<?> manualStartMatchHouse() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        System.out.println("执行一次"+ sdf.format(new Date()));

        // 判断当前是否在运行，如果不是就启动
        boolean runState = MateRuleAction.runState;
        if (!runState) {
            mateRuleAction.initData();
            try {
                mateRuleAction.start();
            } catch (InterruptedException e) {
                e.printStackTrace();
                return Result.error("-1", "启动失败，程序出错");
            }
            return Result.success();
        }
        return Result.error("-1", "当前已正在运行，无序手动start");
    }
}
package com.like.controller;