基于javaweb+mysql的springboot大学生在线答疑平台(java+springboot+maven+vue+elementui+mysql)

基于javaweb+mysql的springboot大学生在线答疑平台(java+springboot+maven+vue+elementui+mysql)

私信源码获取及调试交流

运行环境

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

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

❗没学过node.js的不要搞前后端分离项目

适用

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

功能说明

基于javaweb的SpringBoot大学生在线答疑平台(java+springboot+maven+vue+elementui+mysql)

分为后台管理员、老师、学生

后端：SpringBoot(Spring+SpringMVC+Mybatis)

前端：Vue+ElementUI

        } catch (OperatorFailureException ofe) {
            ofe.printStackTrace();
            return ResultMsg.create(ofe.getCode(), ofe.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);
        }
    }

    /**
     * 删除用户
     *
     * @param param
     * @return
     */
    @DeleteMapping("/delete")
    @Permission
    public ResultMsg delete(@RequestBody JSONObject param) {
        try {
            if (param == null || !param.containsKey(SysConst.BATCH_ID)
                    || !param.getString(SysConst.BATCH_ID).contains(",")) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }
            String ids = param.getString(SysConst.BATCH_ID);
            userInfoService.remove(ids);
            return ResultMsg.success();
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.DELETE_FAILUER, StatusCode.DELETE_FAILUER_MSG);
        }
    }

    /**
     * 修改密码
     *
     * @param authen 封装新旧密码的实体
     * @return 响应码，响应信息
     */

    @PostMapping("/updatePassword")
    @Permission
    public ResultMsg updatePassword(@RequestBody SysUserLocalAuthen authen) {

/**
 * 权限控制拦截器
 *
 * @Version 1.0
 */
@Slf4j
@Component
public class AuthorizationInterceptor implements HandlerInterceptor {
    @Autowired
    private TokenUtil tokenUtil;
    @Autowired
    private IResourcesService resourcesService;
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        try {
            if (!(handler instanceof HandlerMethod)) {   // 其实是对静态资源放行
                return true;
            }
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            // 判断是否带有permission注解  带有此注解的需要权限鉴定，
            Permission permission = method.getAnnotation(Permission.class);
            if (permission == null) {
                return true;  // 没有注解的 直接放行
            }
            String token = request.getHeader(SysConst.RESULT_MAP_TOKEN);
            Integer userId = tokenUtil.getUserId(token);
            if (userId != null)
                request.setAttribute(SysConst.CURRENT_USER_ID, userId);

     * 获取用户回答
     *
     * @param param
     * @return
     */
    @RequestMapping("/queryAnswer")
    @Permission
    public ResultMsg queryAnswer(HttpServletRequest httpRequest, @RequestBody JSONObject param) {
        try {
            //查询条件
            Answer answer = null;
            if (param.containsKey(SysConst.QUERY_CONDITION_KEY)) {
                answer = param.getObject(SysConst.QUERY_CONDITION_KEY, Answer.class);
            } else {
                answer = new Answer();
            }
            Integer currentUserId = getCurrentUserId(httpRequest);
            answer.setUserId(currentUserId);
            answer.setAnswerOwn(SysConst.ANSWER_PLAIN);
            //分页查询
            if (param.containsKey(SysConst.PAGA_CURRENT_KEY) && param.containsKey(SysConst.PAGA_SIZE_KEY)) {
                IPage<Answer> answerPage = new Page<>();
                answerPage.setCurrent(param.getLong(SysConst.PAGA_CURRENT_KEY)).setSize(param.getLong(SysConst.PAGA_SIZE_KEY));
                IPage<Answer> list = answerService.queryByCondition(answerPage, answer);
                return ResultMsg.success(list);
            } else {  //普通查询
                List<Answer> list = answerService.queryByCondition(answer);
                return ResultMsg.success(list);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 获取用户举报
     *
     * @param httpRequest
     * @return

    public ResultMsg report(HttpServletRequest httRequest, @RequestBody Report report) {
        try {
            if (report == null) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }
            report.setUserId(getCurrentUserId(httRequest));
            // 如果查出相同的，拦截掉，不让修改
            Report retReport = reportService.getOne(new QueryWrapper<Report>().lambda()
                    .eq(Report::getReqAnsId, report.getReqAnsId())
                    .eq(Report::getReqAnsType, report.getReqAnsType()));
            if (retReport != null) return ResultMsg.create(StatusCode.DATA_EXIST, StatusCode.DATA_EXIST_MSG);
            reportService.save(report);
            return ResultMsg.success();
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);
        }
    }

    @RequestMapping("/adopt")
    @Permission
    public ResultMsg adopt(HttpServletRequest httRequest, @RequestBody Adopte adopte) {
        try {
            if (adopte == null) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }

            adopte.setUserId(getCurrentUserId(httRequest));
            // 如果查出相同的，拦截掉，不让修改
            Request retRequest = isRequestorOwn(adopte.getUserId(), adopte.getRequestId());
            if (!Objects.isNull(retRequest))
                return ResultMsg.create(StatusCode.ILLEGAL_OPERATION, StatusCode.ILLEGAL_OPERATION_MESSAGE);
            retRequest = new Request();
            retRequest.setUpdateAt(LocalDateTime.now()).setBestAnswerId(adopte.getAnswerId());
            // 保存采纳的值
            requestService.update(retRequest,
                    new UpdateWrapper<Request>().lambda().eq(Request::getTid, adopte.getRequestId()));
            return ResultMsg.success();
        } catch (Exception e) {
            e.printStackTrace();

                    // 首次登录
                    // 保存用户信息
                    SysUserInfo sysUserInfo = new SysUserInfo()
                            .setName(wxAuthResultMedel.getOpenid()).setRoleId(4);
                    iSysUserInfoService.wxSave(sysUserInfo);
                    Integer userIdTemp = sysUserInfo.getTid();
                    // 保存 微信 openId
                    UserThirdAuthen userThirdAuthen = new UserThirdAuthen();
                    userThirdAuthen.setOuthType("wx")
                            .setUserId(userIdTemp)
                            .setOpenid(wxAuthResultMedel.getOpenid())
                            .setSessionKey(wxAuthResultMedel.getSession_key())
                            .setUnionid(wxAuthResultMedel.getUnionid());
                    thirdAuthenService.save(userThirdAuthen);
                    // TODO 获取access_token
                    userId = userIdTemp;
                } else {
                    // 二次登录
                    userId = userThirdAuthenDb.getUserId();
                    SysUserInfo userInfoTemp = iSysUserInfoService.getById(userId);
                    userInfo = wxAuthResultMedel.getOpenid().equals(userInfoTemp.getName()) ? null : userInfoTemp;
                }
                // 签发token
                String token = tokenUtil.createToken(userId);
                Map<String, Object> resultMap = new HashMap<>();
                resultMap.put("token", token);
                resultMap.put("userInfo", userInfo);
                return ResultMsg.success(resultMap);
            } else {
                // TODO 错误情况 还需要单独处理
                return ResultMsg.create(Integer.parseInt(errcode), wxAuthResultMedel.getErrmsg());
            }
            // TODO 异常也需要做处理
        }
        return ResultMsg.create(-1, "获取未获取到信息！");
    }

    public static void main(String[] args) {
        Map<String, String> param = new HashMap<>();
        param.put(WX_AUTH_APPID, "fsd");
        param.put(WX_AUTH_SECRET, "sdfs");
        param.put(WX_AUTH_GRANT_TYPE, "sdfsd");
        param.put("js_code", "sdfsd");

    @RequestMapping("/queryByCondition")
    public ResultMsg queryByCondition(@RequestBody JSONObject param) {
        try {
            //查询条件
            SysUserInfo userInfo = null;
            if (param.containsKey(SysConst.QUERY_CONDITION_KEY)) {
                userInfo = param.getObject(SysConst.QUERY_CONDITION_KEY, SysUserInfo.class);
            } else {
                userInfo = new SysUserInfo();
            }
            // 构建查询条件，只查询管理员和超级管理员
            ArrayList<String> roleKeyList = new ArrayList<>();
            roleKeyList.add(SysConst.ROLE_KEY_ADMIN);
            roleKeyList.add(SysConst.ROLE_KEY_SUPER_ADMIN);
            userInfo.setRoleKeyList(roleKeyList);

            //分页查询
            if (param.containsKey(SysConst.PAGA_CURRENT_KEY) && param.containsKey(SysConst.PAGA_SIZE_KEY)) {
                IPage<SysUserInfo> userInfoPage = new Page<>();
                userInfoPage.setCurrent(param.getLong(SysConst.PAGA_CURRENT_KEY)).setSize(param.getLong(SysConst.PAGA_SIZE_KEY));
                IPage<SysUserInfo> list = userInfoService.queryByCondition(userInfoPage, userInfo);
                return ResultMsg.success(list);
            } else {  //普通查询
                List<SysUserInfo> list = userInfoService.queryByCondition(userInfo);
                return ResultMsg.success(list);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 获取下拉选择的数据
     *
     * @return
     */
    @RequestMapping("/getSelectData")
    @Permission
    public ResultMsg getSelectData() {

    /**
     * TODO 方法加权限验证
     * 重新开通答疑室
     *
     * @return
     */
    @RequestMapping("/restartRoom")
    @Permission
    public ResultMsg restartRoom(HttpServletRequest request) {
        try {
            Integer currentUserId = getCurrentUserId(request);
            raroomService.changeRoomStatus(currentUserId,SysConst.RA_ROOM_STATUS_OK);
            return retSuccess();
        } catch (OperatorFailureException ofe) {
            ofe.printStackTrace();
            return retOperatorFalueException(ofe);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.OPERATOR_FAILURE, StatusCode.OPERATOR_FAILURE_MSG);
        }
    }

    /**
     * 查询个人的答疑室列表
     *
     * @return
     */
    @RequestMapping("/queryMyRaRoomList")
    @Permission
    public ResultMsg queryMyRaRoomList(HttpServletRequest request) {
        try {
            //查询条件
            Integer currentUserId = getCurrentUserId(request);
            Map map = raroomService.queryMyRaRoomList(currentUserId);
            return ResultMsg.success(map);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 查询答疑室的所属者
     *
     * @param param
     * @return
     */

    /**
     * 获取所有专业课程，课程专业对应关系  前端在用，不能加权限验证
     * @return
     */
    @RequestMapping("/getAllProfessionCourse")
    public ResultMsg getAllProfessionCourse(){
        try {
            List<Course> courseList = courseService.list();
            List<Profession> professionList = professionService.list();
            List<ProfessionCourseRelation> relationList = relationService.list();

            // 把查询的结果放到map集合
            HashMap<String, List> allProfessionCourse = new HashMap<>();
            allProfessionCourse.put(ALL_COURSE_LIST,courseList);
            allProfessionCourse.put(ALL_PROFESSION_LIST,professionList);
            allProfessionCourse.put(ALL_RELATION_LIST,relationList);
            return ResultMsg.success(allProfessionCourse);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }
}

                return ResultMsg.create(StatusCode.DELETE_FAILUER, StatusCode.DELETE_FAILUER_MSG);
            }
        }

        *//**
     * 获取分配课程的数据
     *
     * @param param
     * @return
     *//*
        @RequestMapping("/getAssinCourseData")
        public ResultMsg getAssinCourseData(@RequestBody JSONObject param) {
            try {
                String professionId = param.getString(SysConst.ID);
                if (StringUtils.isEmpty(professionId)) {
                    return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
                }
                AssinCourse assinCourseData = professionService.getAssinCourseData(professionId);
                return ResultMsg.success(assinCourseData);
            } catch (Exception e) {
                e.printStackTrace();
                return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
            }
        }

        *//**
     * 保存分配课程的数据
     *
     * @param assinCourse
     * @return
     *//*
        @RequestMapping("/saveAssinCourseData")
        public ResultMsg saveAssinCourseData(@RequestBody AssinCourse assinCourse) {
            try {
                if (Objects.isNull(assinCourse)) {
                    return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
                }
                // 保存分配的课程
                professionService.saveAsignCourse(assinCourse);
                return ResultMsg.success();
            } catch (Exception e) {
                e.printStackTrace();
                return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);
            }
        }

        *//**
     * 获取专业和课程的对应关系
     *
     * @return 返回所有专业的数组

    @PostMapping("/answer")
    @Permission
    public ResultMsg answer(HttpServletRequest request, @RequestBody Answer answer) {
        try {
            if (answer == null) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }
            // 给修改日期赋值
            Integer currentUserId = getCurrentUserId(request);
            answer.setUserId(currentUserId).setPid(-1);
            answerService.saveOrUpdate(answer);
            return ResultMsg.success();
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);
        }
    }

    /**
     * 删除 问答
     *
     * @param deleteRequest
     * @return
     */
    @DeleteMapping("/delete")
    @Permission
    public ResultMsg delete(HttpServletRequest httRequest, @RequestBody RaRomDeleteRequest deleteRequest) {
        try {
            if (deleteRequest == null) {
                return retParamFailure();
            }
            Integer userId = getCurrentUserId(httRequest);
            if (!isRoomOpen(userId)) retRoomStatusNotOpen();
            if (!isRoomTeacher(userId, deleteRequest.getRoomId())) retNotOwnOperatorFailure(); // 非答疑室教师本人操作
            // 设置roomId
            Integer roomId = getRoomIdByTeacherId(userId);
            deleteRequest.setRoomId(roomId);
            // 删除
            requestRalationService.remove(deleteRequest);
            return ResultMsg.success();
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.DELETE_FAILUER, StatusCode.DELETE_FAILUER_MSG);
        }
    }

}

    /**
     * 条件查询
     *
     * @param param
     * @return
     */
    @RequestMapping("/queryByCondition")
    public ResultMsg queryByCondition(@RequestBody JSONObject param) {
        try {
            //查询条件
            Profession profession = null;
            if (param.containsKey(SysConst.QUERY_CONDITION_KEY)) {
                profession = param.getObject(SysConst.QUERY_CONDITION_KEY, Profession.class);
            }
            //分页查询
            if (param.containsKey(SysConst.PAGA_CURRENT_KEY) && param.containsKey(SysConst.PAGA_SIZE_KEY)) {
                IPage<Profession> page = new Page<>();
                page.setCurrent(param.getLong(SysConst.PAGA_CURRENT_KEY)).setSize(param.getLong(SysConst.PAGA_SIZE_KEY));
                IPage<Profession> list = professionService.queryByCondition(page, profession);
                return ResultMsg.success(list);
            } else {  //普通查询
                List<Profession> list = professionService.queryByCondition(profession);
                return ResultMsg.success(list);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 保存
     *
     * @param profession
     * @return
     */
    @PostMapping("/save")
    public ResultMsg save(@RequestBody Profession profession) {
        try {
            if (profession == null) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }
            // 给修改日期赋值

            } else {  //普通查询
                List<SysUserInfo> list = userInfoService.queryByCondition(userInfo);
                return ResultMsg.success(list);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 获取下拉选择的数据
     *
     * @return
     */
    @RequestMapping("/getSelectData")
    @Permission
    public ResultMsg getSelectData() {
        try {
            Map<String, Object> map = userInfoService.getSelectData(SysConst.ROLE_KEY_SUPER_ADMIN);
            return ResultMsg.success(map);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 保存用户
     *
     * @param userInfo
     * @return
     */
    @PostMapping("/save")
    @Permission
    public ResultMsg save(@RequestBody SysUserInfo userInfo) {
        try {
            if (userInfo == null) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }
            // 设置roleid
            Integer roleId = roleService.getRoleIdByKey(SysConst.ROLE_KEY_ADMIN);
            userInfo.setRoleId(roleId);
            // 保存用户
            if (!userInfoService.save(userInfo)) {
                return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);
            }
            return ResultMsg.success();
        } catch (OperatorFailureException ofe) {
            ofe.printStackTrace();
            return ResultMsg.create(ofe.getCode(), ofe.getMessage());
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);

 * @Version 1.0
 */
@CrossOrigin
@RestController
@RequestMapping("/api/admin/rm/report")
@Slf4j
public class ReportHandleController {

    @Autowired
    private IReportService reportService;

    private static final String HANDLE_TYPE = "handleType";

    /**
     * 按条件查询
     *
     * @param param
     * @return
     */
    @RequestMapping("/queryByCondition")
    @Permission
    public ResultMsg queryByCondition(@RequestBody JSONObject param) {
        try {
            //查询条件
            Report report = null;
            if (param.containsKey(SysConst.QUERY_CONDITION_KEY)) {
                report = param.getObject(SysConst.QUERY_CONDITION_KEY, Report.class);
            }
            //分页查询
            if (param.containsKey(SysConst.PAGA_CURRENT_KEY) && param.containsKey(SysConst.PAGA_SIZE_KEY)) {
                IPage<Report> page = new Page<>();
                page.setCurrent(param.getLong(SysConst.PAGA_CURRENT_KEY)).setSize(param.getLong(SysConst.PAGA_SIZE_KEY));
                IPage<Report> list = reportService.queryByCondition(page, report);
                return ResultMsg.success(list);
            } else {  //普通查询
                reportService.queryByCondition(report);
                return ResultMsg.success(report);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 举报处理
     *
     * @param param
     * @return
     */

            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

}

/**
 * 答疑室学生相关控制器
 *
 * @Version 1.0
 */
@RestController
@CrossOrigin
@Slf4j
@RequestMapping("/api/web/raroom/student")
public class RaRoomStudentController extends RaroomBaseController {

    @Autowired
    private IRaroomStudentRalationService studentRalationService;

    /**
     * 查询答疑室文件  RoomId 为必填字段
     *
     * @return
     */
    @Permission
    @RequestMapping("/queryByCondition")
    public ResultMsg queryByCondition(HttpServletRequest request, @RequestBody JSONObject param) {
        try {
            //查询条件
            if (!param.containsKey(SysConst.QUERY_CONDITION_KEY)) {

 * 前端控制器
 * </p>
 *
 */
@RestController
@RequestMapping("/api/admin/rs/role")
@CrossOrigin
public class RoleController {

    @Autowired
    private IRoleService roleService;

    /**
     * 那条件查询
     *
     * @param param
     * @return
     */
    @RequestMapping("/queryByCondition")
    @Permission
    public ResultMsg queryByCondition(@RequestBody JSONObject param) {
        try {
            //查询条件
            Role role = null;
            if (param.containsKey(SysConst.QUERY_CONDITION_KEY)) {
                role = param.getObject(SysConst.QUERY_CONDITION_KEY, Role.class);
            }
            //分页查询
            if (param.containsKey(SysConst.PAGA_CURRENT_KEY) && param.containsKey(SysConst.PAGA_SIZE_KEY)) {
                IPage<Role> page = new Page<>();
                page.setCurrent(param.getLong(SysConst.PAGA_CURRENT_KEY)).setSize(param.getLong(SysConst.PAGA_SIZE_KEY));
//                    IPage<Role> list = professionService.queryByCondition(page, role);
                List<Role> list = roleService.list(null);
                return ResultMsg.success(list);
            } else {  //普通查询
                List<Role> list = roleService.list();
                return ResultMsg.success(list);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**

        }

        *//**
     * 获取分配课程的数据
     *
     * @param param
     * @return
     *//*
        @RequestMapping("/getAssinCourseData")
        public ResultMsg getAssinCourseData(@RequestBody JSONObject param) {
            try {
                String professionId = param.getString(SysConst.ID);
                if (StringUtils.isEmpty(professionId)) {
                    return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
                }
                AssinCourse assinCourseData = professionService.getAssinCourseData(professionId);
                return ResultMsg.success(assinCourseData);
            } catch (Exception e) {
                e.printStackTrace();
                return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
            }
        }

        *//**
     * 保存分配课程的数据
     *
     * @param assinCourse
     * @return
     *//*
        @RequestMapping("/saveAssinCourseData")
        public ResultMsg saveAssinCourseData(@RequestBody AssinCourse assinCourse) {
            try {
                if (Objects.isNull(assinCourse)) {
                    return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
                }
                // 保存分配的课程
                professionService.saveAsignCourse(assinCourse);
                return ResultMsg.success();
            } catch (Exception e) {
                e.printStackTrace();
                return ResultMsg.create(StatusCode.SAVE_FAILURE, StatusCode.SAVE_FAILURE_MSG);
            }
        }

            try {
                List<Course> courseList = courseService.list();
                List<Profession> professionList = professionService.list();
                List<ProfessionCourseRelation> relationList = relationService.list();

                // 把查询的结果放到map集合
                HashMap<String, List> allProfessionCourse = new HashMap<>();
                allProfessionCourse.put(ALL_COURSE_LIST,courseList);
                allProfessionCourse.put(ALL_PROFESSION_LIST,professionList);
                allProfessionCourse.put(ALL_RELATION_LIST,relationList);
                return ResultMsg.success(allProfessionCourse);
            } catch (Exception e) {
                e.printStackTrace();
                return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
            }
        }*/

}

            } else {  //普通查询
                List<Collect> list = collectService.queryByCondition(collect);
                return ResultMsg.success(list);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }

    /**
     * 收藏跳转详情
     *
     * @return
     */
    @PostMapping("/collectDetail")
    public ResultMsg collectDetail(Integer reqAnsType, Integer requestId, Integer reqAnsId) {
        try {
            if (StringUtils.isEmpty(reqAnsType) || StringUtils.isEmpty(requestId) || StringUtils.isEmpty(reqAnsId)) {
                return ResultMsg.create(StatusCode.PARAMETER_ERROR, StatusCode.PARAMETER_ERROR_MSG);
            }
            Request request = userMainService.collectDetail(reqAnsType, requestId, reqAnsId);
            return ResultMsg.success(request);
        } catch (Exception e) {
            e.printStackTrace();
            return ResultMsg.create(StatusCode.QUERY_FAILURE, StatusCode.QUERY_FAILURE_MSG);
        }
    }
}