sourcecode/server/gateway-api/src/main/java/com/qxgmat/controller/api/MyController.java

package com.qxgmat.controller.api;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.Page;
import com.nuliji.tools.*;
import com.nuliji.tools.exception.ParameterException;
import com.nuliji.tools.exception.SystemException;
import com.qxgmat.data.constants.enums.MessageType;
import com.qxgmat.data.constants.enums.QuestionSubject;
import com.qxgmat.data.constants.enums.QuestionType;
import com.qxgmat.data.constants.enums.SettingKey;
import com.qxgmat.data.constants.enums.module.*;
import com.qxgmat.data.constants.enums.status.AskStatus;
import com.qxgmat.data.constants.enums.status.DirectionStatus;
import com.qxgmat.data.constants.enums.user.DataType;
import com.qxgmat.data.dao.entity.*;
import com.qxgmat.data.inline.PaperStat;
import com.qxgmat.data.inline.UserQuestionStat;
import com.qxgmat.data.relation.entity.*;
import com.qxgmat.dto.extend.*;
import com.qxgmat.dto.request.*;
import com.qxgmat.dto.request.CommentDto;
import com.qxgmat.dto.request.FaqDto;
import com.qxgmat.dto.request.UserCollectQuestionDto;
import com.qxgmat.dto.request.UserNoteQuestionDto;
import com.qxgmat.dto.response.*;
import com.qxgmat.help.AiHelp;
import com.qxgmat.help.MailHelp;
import com.qxgmat.help.ShiroHelp;
import com.qxgmat.service.*;
import com.qxgmat.service.extend.*;
import com.qxgmat.service.inline.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.tools.Tool;
import javax.validation.Validator;
import java.io.File;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * Created by GaoJie on 2017/10/31.
 */
@RestController
@RequestMapping("/api/my")
@Api(tags = "用户接口", description = "获取与操作当前用户信息", produces = MediaType.APPLICATION_JSON_VALUE)
public class MyController {

    @Value("${upload.local_path}")
    private String localPath;

    @Value("${upload.web_url}")
    private String webUrl;

    @Autowired
    private Validator validator;

    @Autowired
    private ShiroHelp shiroHelp;

    @Autowired
    private AiHelp aiHelp;

    @Autowired
    private MailHelp mailHelp;

    @Autowired
    private PreviewService previewService;

    @Autowired
    private SettingService settingService;

    @Autowired
    private ExerciseStructService exerciseStructService;

    @Autowired
    private CourseService courseService;

    @Autowired
    private CourseNoService courseNoService;

    @Autowired
    private QuestionService questionService;

    @Autowired
    private QuestionNoService questionNoService;

    @Autowired
    private SentenceQuestionService sentenceQuestionService;

    @Autowired
    private TextbookQuestionService textbookQuestionService;

    @Autowired
    private TextbookTopicService textbookTopicService;

    @Autowired
    private TextbookLibraryService textbookLibraryService;

    @Autowired
    private CourseDataService courseDataService;

    @Autowired
    private CourseExperienceService courseExperienceService;

    @Autowired
    private CourseDataHistoryService courseDataHistoryService;

    @Autowired
    private CourseTeacherService courseTeacherService;

    @Autowired
    private FaqService faqService;

    @Autowired
    private CommentService commentService;

    @Autowired
    private PreviewAssignService previewAssignService;

    @Autowired
    private UsersService usersService;

    @Autowired
    private UserMessageService userMessageService;

    @Autowired
    private UserCourseRecordService userCourseRecordService;

    @Autowired
    private UserCourseAppointmentService userCourseAppointmentService;

    @Autowired
    private UserCourseProgressService userCourseProgressService;

    @Autowired
    private UserSentenceRecordService userSentenceRecordService;

    @Autowired
    private UserServiceService userServiceService;

    @Autowired
    private UserCollectQuestionService userCollectQuestionService;

    @Autowired
    private UserCollectExperienceService userCollectExperienceService;

    @Autowired
    private UserNoteQuestionService userNoteQuestionService;

    @Autowired
    private UserNoteCourseService userNoteCourseService;

    @Autowired
    private UserAskQuestionService userAskQuestionService;

    @Autowired
    private UserAskCourseService userAskCourseService;

    @Autowired
    private UserFeedbackErrorService userFeedbackErrorService;

    @Autowired
    private UserTextbookFeedbackService userTextbookFeedbackService;

    @Autowired
    private UserQuestionService userQuestionService;

    @Autowired
    private UserReportService userReportService;

    @Autowired
    private UserPaperService userPaperService;

    @Autowired
    private UserPaperQuestionService userPaperQuestionService;

    @Autowired
    private UserOrderService userOrderService;

    @Autowired
    private UserOrderRecordService userOrderRecordService;

    @Autowired
    private QuestionFlowService questionFlowService;

    @Autowired
    private SentenceService sentenceService;

    @Autowired
    private CourseExtendService courseExtendService;

    @Autowired
    private OrderFlowService orderFlowService;

    @Autowired
    private MessageExtendService messageExtendService;

    @RequestMapping(value = "/email", method = RequestMethod.POST)
    @ApiOperation(value = "绑定邮箱", httpMethod = "POST")
    public Response<Boolean> email(@RequestBody @Validated UserEmailDto dto, HttpSession session, HttpServletRequest request) {
        User user = (User) shiroHelp.getLoginUser();
        usersService.edit(User.builder()
                .id(user.getId())
                .email(dto.getEmail())
                .build());
        messageExtendService.sendEmailChange(user);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/mobile", method = RequestMethod.POST)
    @ApiOperation(value = "绑定手机", httpMethod = "POST")
    public Response<Boolean> mobile(@RequestBody @Validated UserMobileDto dto, HttpSession session, HttpServletRequest request) {
        User user = (User) shiroHelp.getLoginUser();
        User in = usersService.get(user.getId());
        if (in.getArea().equals(dto.getArea()) && in.getMobile().equals(dto.getMobile())) {
            return ResponseHelp.success(true);
        }
        User other = usersService.getByMobile(dto.getArea(), dto.getMobile());
        if (other != null){
            throw new ParameterException("该手机已绑定其他账号，请更换手机号码");
        }
        usersService.edit(User.builder()
                .id(user.getId())
                .area(dto.getArea())
                .mobile(dto.getMobile())
                .build());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/info", method = RequestMethod.POST)
    @ApiOperation(value = "修改用户信息", httpMethod = "POST")
    public Response<Boolean> info(@RequestBody @Validated UserInfoDto dto){
        User user = (User) shiroHelp.getLoginUser();
        usersService.edit(User.builder()
                .id(user.getId())
                .nickname(dto.getNickname())
                .avatar(dto.getAvatar())
                .build());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/real/front", produces = MediaType.IMAGE_JPEG_VALUE, method = RequestMethod.POST)
    @ApiOperation(value = "实名认证", notes = "保存用户实名信息", httpMethod = "POST")
    public Response<UserRealDto> realFront(@RequestParam("file") MultipartFile file) throws IOException {
        if (file.isEmpty()) {
            throw new ParameterException("上传文件为空");
        }
        User user = (User) shiroHelp.getLoginUser();
        UserRealDto dto = new UserRealDto();

        Map<String, String> map = aiHelp.orcIdcardFront(file.getBytes());
        dto.setName(map.get("name"));
        dto.setAddress(map.get("address"));
        dto.setIdentity(map.get("identity"));

        User in = usersService.getByIdentity(map.get("identity"));
        if (in != null){
            throw new ParameterException("该身份证已被其他账号认证");
        }

        String frontName = UUID.randomUUID().toString();
        try {
            File frontDest = new File(localPath + File.separator+frontName);
            file.transferTo(frontDest);
            dto.setPhotoFront(webUrl+frontName);
            usersService.edit(User.builder()
                    .id(user.getId())
                    .realAddress(dto.getAddress())
                    .realName(dto.getName())
                    .realIdentity(dto.getIdentity())
                    .realPhotoFront(dto.getPhotoFront())
                    .build());
            return ResponseHelp.success(dto);
        } catch (IOException e) {
            e.printStackTrace();
            return ResponseHelp.exception(new SystemException("图片上传失败"));
        }
    }

    @RequestMapping(value = "/real/back", produces = MediaType.IMAGE_JPEG_VALUE, method = RequestMethod.POST)
    @ApiOperation(value = "实名认证", notes = "保存用户实名信息", httpMethod = "POST")
    public Response<UserRealDto> realBack(@RequestParam("file") MultipartFile file) throws IOException {
        if (file.isEmpty()) {
            throw new ParameterException("上传文件为空");
        }
        User user = (User) shiroHelp.getLoginUser();
        UserRealDto dto = new UserRealDto();

        aiHelp.orcIdcardBack(file.getBytes());
        String backName = UUID.randomUUID().toString();
        try {
            File backDest = new File(localPath + File.separator+backName);
            file.transferTo(backDest);
            dto.setPhotoBack(webUrl+backName);
            usersService.edit(User.builder()
                    .id(user.getId())
                    .realPhotoBack(dto.getPhotoBack())
                    .build());
            return ResponseHelp.success(dto);
        } catch (IOException e) {
            e.printStackTrace();
            return ResponseHelp.exception(new SystemException("图片上传失败"));
        }
    }

    @RequestMapping(value = "/real/finish", produces = MediaType.IMAGE_JPEG_VALUE, method = RequestMethod.POST)
    @ApiOperation(value = "实名认证", notes = "保存用户实名信息", httpMethod = "POST")
    public Response<UserRealDto> realFinish() {
        User user = (User) shiroHelp.getLoginUser();
        UserRealDto dto = new UserRealDto();

        User in = usersService.get(user.getId());
        if (in.getRealAddress() == null || !in.getRealAddress().equals("")){
            throw new ParameterException("实名认证流程错误");
        }
        if (in.getRealIdentity() == null || !in.getRealIdentity().equals("")){
            throw new ParameterException("实名认证流程错误");
        }
        if (in.getRealName() == null || !in.getRealName().equals("")){
            throw new ParameterException("实名认证流程错误");
        }
        if (in.getRealPhotoFront() == null || !in.getRealPhotoFront().equals("")){
            throw new ParameterException("实名认证流程错误");
        }
        if (in.getRealPhotoBack() == null || !in.getRealPhotoBack().equals("")){
            throw new ParameterException("实名认证流程错误");
        }

        usersService.edit(User.builder()
                .id(user.getId())
                .realStatus(1)
                .realTime(new Date())
                .build());
        orderFlowService.giveReal(user.getId());
        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/invite/email", method = RequestMethod.POST)
    @ApiOperation(value = "发送邮件邀请", httpMethod = "POST")
    public Response<Boolean> inviteEmail(@RequestBody @Validated InviteEmailDto dto)  {
        User user = (User) shiroHelp.getLoginUser();
        messageExtendService.sendInviteEmail(user, dto.getEmails(), user.getInviteCode());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/message", method = RequestMethod.GET)
    @ApiOperation(value = "用户站内信", notes = "用户消息列表", httpMethod = "GET")
    public Response<PageMessage<UserMessage>> message(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String messageType,
            @RequestParam(required = false) Integer read
    )  {
        User user = (User) shiroHelp.getLoginUser();
        Page<UserMessage> p = userMessageService.list(page, size, user.getId(), MessageType.ValueOf(messageType), read);

        return ResponseHelp.success(p, page, size, p.getTotal());
    }

    @RequestMapping(value = "/message/read", method = RequestMethod.PUT)
    @ApiOperation(value = "读取消息", notes = "读取用户消息/全部", httpMethod = "PUT")
    public Response<Boolean> readMessage(@RequestBody @Validated MessageReadDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        if (dto.getAll()){
            userMessageService.clearAll(user.getId());
        }else{
            userMessageService.clear(user.getId(), dto.getId());
        }

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/clear/exercise/latest", method = RequestMethod.PUT)
    @ApiOperation(value = "清除最后一次做题记录", notes = "清除最后一次做题记录", httpMethod = "PUT")
    public Response<Boolean> clearLatestExercise()  {
        User user = (User) shiroHelp.getLoginUser();
        usersService.edit(User.builder().id(user.getId()).latestExercise(0).build());

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/clear/error/latest", method = RequestMethod.PUT)
    @ApiOperation(value = "清除最后一次错题组卷做题记录", notes = "清除最后一次错题组卷做题记录", httpMethod = "PUT")
    public Response<Boolean> clearLatestError()  {
        User user = (User) shiroHelp.getLoginUser();
        usersService.edit(User.builder().id(user.getId()).latestError(0).build());

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/prepare", method = RequestMethod.PUT)
    @ApiOperation(value = "修改备考信息", notes = "修改用户备考信息", httpMethod = "PUT")
    public Response<Boolean> editPrepare(@RequestBody @Validated UserPrepareDto dto)  {
        User entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setId(user.getId());
        if (user.getPrepareTime() == null){
            // 邀请奖励
            orderFlowService.givePrepare(user.getId());
        }
        entity.setPrepareTime(new Date());
        usersService.edit(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/prepare", method = RequestMethod.GET)
    @ApiOperation(value = "获取备考信息", notes = "获取备考信息及分布", httpMethod = "GET")
    public Response<UserPrepareDetailDto> getPrepare()  {
        User user = (User) shiroHelp.getLoginUser();
        User entity = usersService.get(user.getId());
        UserPrepareDetailDto dto = Transform.convert(entity, UserPrepareDetailDto.class);

        Setting setting = settingService.getByKey(SettingKey.PREPARE_INFO);
        JSONObject value = setting.getValue();
        dto.setStat(value);
        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/study", method = RequestMethod.GET)
    @ApiOperation(value = "获取学习记录", notes = "获取选择那天的做题信息", httpMethod = "GET")
    public Response<UserStudyDayDto> studyTime(
            @RequestParam(required = false) String date
    )  {
        User user = (User) shiroHelp.getLoginUser();
        Date day;
        try {
            day = DateFormat.getDateInstance().parse(date);
        } catch (ParseException e) {
            throw new ParameterException("日期格式错误");
        }
        Date endDay = Tools.addDate(day, 1);
        String startTime = day.toString();
        String endTime = endDay.toString();
        UserStudyDayDto dto = new UserStudyDayDto();

        List<ExerciseStruct> p = exerciseStructService.main();
        Map<String, String> m = new HashMap<>();
        for (ExerciseStruct struct : p){
            if (struct.getExtend() == null || struct.getExtend().isEmpty()) continue;
            m.put(struct.getExtend(), struct.getTitleZh() + (struct.getTitleEn().isEmpty() ? "":" "+struct.getTitleEn()));
        }

        // 获取总用户数
        Integer total = usersService.count();

        // 获取练习统计 - 按题型进行分组统计
        Integer exerciseTime = 0;
        Integer exerciseQuestion = 0;
        List<UserExerciseExtendDto> exerciseList = new ArrayList<>();
        List<UserStudyStatRelation> typeList = userReportService.statGroupExerciseType(user.getId(), startTime, endTime);
        for(UserStudyStatRelation type:typeList){
            exerciseTime += type.getUserTime();
            exerciseQuestion += type.getUserNumber();
            exerciseList.add(new UserExerciseExtendDto(m.get(type.getModule()), type.getUserNumber(), type.getUserTime(), type.getUserCorrect()));
        }
        // todo 练习统计排行
        UserRankStatRelation exerciseRank = userReportService.rankExerciseByTime(user.getId(), startTime, endTime);
        exerciseRank.setTotal(total);

        dto.setExerciseTime(exerciseTime);
        dto.setExerciseQuestion(exerciseQuestion);
        dto.setExerciseList(exerciseList);
        dto.setExerciseExceed(exerciseRank);

        // 获取模考统计 - 按卷子
        Integer examinationTime = 0;
        Integer examinationPaper = 0;
        List<UserReport> userReportList = userReportService.getByModule(user.getId(), PaperModule.EXAMINATION, startTime, endTime);
        Collection paperIds = Transform.getIds(userReportList, UserReport.class, "paperId");
        List<UserPaper> userPaperList = userPaperService.select(paperIds);
        Map userPaper = Transform.getMap(userPaperList, UserPaper.class, "id");
        List<UserPaperDetailExtendDto> examinationPaperList = new ArrayList<>(userReportList.size());
        for(UserReport report: userReportList){
            examinationTime += report.getUserTime();
            examinationPaper += 1;
            UserPaperDetailExtendDto d = Transform.convert(userPaper.get(report.getPaperId()), UserPaperDetailExtendDto.class);
            d.setReport(Transform.convert(report, UserReportExtendDto.class));
            examinationPaperList.add(d);
        }
        // todo 模考统计排行
        UserRankStatRelation examinationRank = userReportService.rankExaminationByTime(user.getId(), startTime, endTime);
        examinationRank.setTotal(total);

        dto.setExaminationTime(examinationTime);
        dto.setExaminationPaper(examinationPaper);
        dto.setExaminationList(examinationPaperList);
        dto.setExaminationExceed(examinationRank);

        // 获取课程访问记录 - 按课时
        Integer courseTime = 0;
        Integer courseNumber = 0;
        List<UserCourseRecord> userCourseRecordList = userCourseRecordService.getByTime(user.getId(), startTime, endTime);
        Collection courseIds = Transform.getIds(userCourseRecordList, UserCourseRecord.class, "courseId");
        Collection courseNoIds = Transform.getIds(userCourseRecordList, UserCourseRecord.class, "noId");
        List<Course> courseList = courseService.select(courseIds);
        Map courseMap = Transform.getMap(courseList, Course.class, "id", "title");
        List<CourseNo> courseNoList = courseNoService.select(courseNoIds);
        Map classCourseNoMap = Transform.getMap(courseNoList, CourseNo.class, "id", "content");
        List<UserCourseResultExtendDto> courseResultList = new ArrayList<>(userCourseRecordList.size());
        for(UserCourseRecord record:userCourseRecordList){
            courseTime += record.getUserTime();
            courseNumber += 1;
            UserCourseResultExtendDto d = Transform.convert(record, UserCourseResultExtendDto.class);
            d.setTitle((String)courseMap.get(record.getCourseId()));
            d.setContent((String)classCourseNoMap.get(record.getCourseNoId()));
            courseResultList.add(d);
        }
        // todo 听课统计排行
        UserRankStatRelation classRank = userCourseRecordService.rankByTime(user.getId(), startTime, endTime);
        classRank.setTotal(total);

        dto.setCourseTime(courseTime);
        dto.setCourseNumber(courseNumber);
        dto.setCourseList(courseResultList);
        dto.setCourseExceed(classRank);


        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/study/week", method = RequestMethod.GET)
    @ApiOperation(value = "获取本周记录", notes = "获取本周学习记录", httpMethod = "GET")
    public Response<UserStudyDetailDto> studyWeekTime(
            @RequestParam(required = false) Integer week
    )  {
        User user = (User) shiroHelp.getLoginUser();
        UserStudyDetailDto dto = new UserStudyDetailDto();
        dto.setCreateTime(user.getCreateTime());
        dto.setDays((int)((user.getCreateTime().getTime() - new Date().getTime()) / (1000*3600*24)));

        Date now = Tools.today();
        int day = Tools.getDayOfWeek(now);
        Date start = Tools.addDate(now, -1 * (day + week * 7));
        Date end = Tools.addDate(start, 7);

        Integer time = 0;
        time += courseExtendService.studyTime(user.getId(), start, end);
        time += sentenceService.studyTime(user.getId(), start, end);
        time += questionFlowService.studyTime(user.getId(), start, end);
        dto.setTime(time);

        Integer avgTime = 0;
        avgTime += courseExtendService.studyAvgTime(start, end);
        avgTime += sentenceService.studyAvgTime(start, end);
        avgTime += questionFlowService.studyAvgTime(start, end);
        dto.setAvgTime(avgTime);

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/study/total", method = RequestMethod.GET)
    @ApiOperation(value = "获取总学习记录", notes = "获取总学习记录", httpMethod = "GET")
    public Response<UserStudyDetailDto> studyTotalTime()  {
        User user = (User) shiroHelp.getLoginUser();
        UserStudyDetailDto dto = new UserStudyDetailDto();
        dto.setCreateTime(user.getCreateTime());
        dto.setDays((int)((user.getCreateTime().getTime() - new Date().getTime()) / (1000*3600*24)));
        Integer totalTime = 0;
        Map<String, Integer> categoryMap = new HashMap<>();
        // 按模块来源分组查询: module=> sentence, examination, collect+error, 忽略exercise,preview
        List<UserStudyStatRelation> moduleList = userReportService.statGroupModule(user.getId());
        for(UserStudyStatRelation module:moduleList){
            // 练习时间过滤
            if (module.getModule().equals(PaperModule.EXERCISE.key)){
                continue;
            }
            Integer time = module.getUserTime();
            String key = module.getModule();
            totalTime += time;
            // 收藏及错误组卷合并
            if (module.getModule().equals(PaperOrigin.COLLECT.key)
                    || module.getModule().equals(PaperOrigin.ERROR.key)){
                key = "freedom";
                time += categoryMap.getOrDefault(key, 0);
            }else if (module.getModule().equals(PaperOrigin.PREVIEW.key)){
                key = PaperOrigin.EXERCISE.key;
            }
            categoryMap.put(key, time);
        }
        // 按题型统计练习
        List<UserStudyStatRelation> exerciseList = userReportService.statGroupExerciseType(user.getId(), null, null);
        for(UserStudyStatRelation type:exerciseList){
            totalTime += type.getUserTime();
            categoryMap.put(type.getModule(), type.getUserTime());
        }
        // 按题型统计预习作业
        List<UserStudyStatRelation> previewList = userReportService.statGroupExerciseType(user.getId(), null, null);
        for(UserStudyStatRelation type:previewList){
            totalTime += type.getUserTime();
            categoryMap.put(type.getModule(), type.getUserTime());
        }
        // 按题型统计课程
        List<UserModuleRecordStatRelation> recordList = userCourseRecordService.statGroupType(user.getId(), null, null);
        for (UserModuleRecordStatRelation record : recordList){
            totalTime += record.getUserTime();
            // 累加同类型时间
            Integer time = categoryMap.getOrDefault(record.getModule(), 0);
            categoryMap.put(record.getModule(), time);
        }
        // 获取长难句阅读统计
        UserRecordStatRelation sentenceStatRelation = userSentenceRecordService.stat(user.getId(), null, null);
        if (sentenceStatRelation != null){
            Integer sentenceTime = categoryMap.getOrDefault(PaperModule.SENTENCE.key, 0);
            categoryMap.put(PaperModule.SENTENCE.key, sentenceTime + sentenceStatRelation.getUserTime());
        }

        List<ExerciseStruct> p = exerciseStructService.main();
        Map<String, String> m = new HashMap<>();
        for (ExerciseStruct struct : p){
            if (struct.getExtend() == null || struct.getExtend().isEmpty()) continue;
            m.put(struct.getExtend(), struct.getTitleZh() + (struct.getTitleEn().isEmpty() ? "":" "+struct.getTitleEn()));
        }

        // 组装数据
        List<UserStudyExtendDto> categorys = new ArrayList<>();
        if (categoryMap.containsKey(PaperModule.SENTENCE.key)) categorys.add(new UserStudyExtendDto(m.get(PaperModule.SENTENCE.key), categoryMap.get(PaperModule.SENTENCE.key)));
        if (categoryMap.containsKey(QuestionType.SC.key)) categorys.add(new UserStudyExtendDto(m.get(QuestionType.SC.key), categoryMap.get(QuestionType.SC.key)));
        if (categoryMap.containsKey(QuestionType.RC.key)) categorys.add(new UserStudyExtendDto(m.get(QuestionType.RC.key), categoryMap.get(QuestionType.RC.key)));
        if (categoryMap.containsKey(QuestionType.CR.key)) categorys.add(new UserStudyExtendDto(m.get(QuestionType.CR.key), categoryMap.get(QuestionType.CR.key)));
        if (categoryMap.containsKey(QuestionType.PS.key)){
            // 累加数学
            Integer time = categoryMap.getOrDefault(QuestionSubject.QUANT.key, 0);
            categoryMap.put(QuestionSubject.QUANT.key, time + categoryMap.get(QuestionType.PS.key));
        }
        if (categoryMap.containsKey(QuestionType.DS.key)){
            // 累加数学
            Integer time = categoryMap.getOrDefault(QuestionSubject.QUANT.key, 0);
            categoryMap.put(QuestionSubject.QUANT.key, time + categoryMap.get(QuestionType.DS.key));
        }
        if (categoryMap.containsKey(QuestionSubject.QUANT.key)) categorys.add(new UserStudyExtendDto(m.get(QuestionSubject.QUANT.key), categoryMap.get(QuestionSubject.QUANT.key)));

        if (categoryMap.containsKey(QuestionType.IR.key)) categorys.add(new UserStudyExtendDto(m.get(QuestionType.IR.key), categoryMap.get(QuestionType.IR.key)));
        if (categoryMap.containsKey(QuestionType.AWA.key)) categorys.add(new UserStudyExtendDto(m.get(QuestionType.AWA.key), categoryMap.get(QuestionType.AWA.key)));
        if (categoryMap.containsKey(PaperModule.EXAMINATION.key)) categorys.add(new UserStudyExtendDto("模考", categoryMap.get(PaperModule.EXAMINATION.key)));
        if (categoryMap.containsKey("freedom")) categorys.add(new UserStudyExtendDto("自由组卷", categoryMap.get("freedom")));

        dto.setTime(totalTime);
        dto.setCategorys(categorys);
        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/data", method = RequestMethod.GET)
    @ApiOperation(value = "获取做题数据", notes = "获取做题数据", httpMethod = "GET")
    public Response<Map<String, UserDataDto>> questionData(
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String subject,
            @RequestParam(required = false) Integer[] structIds,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime
    )  {
        User user = (User) shiroHelp.getLoginUser();

        QuestionSubject questionSubject = QuestionSubject.ValueOf(subject);
        StructModule structModule = StructModule.ValueOf(module);
        List<QuestionNo> questionNoList = questionNoService.listByStruct(structModule, structIds);
        List<QuestionNoRelation> relationList = questionNoService.relation(questionNoList);
        Map<Number, QuestionNoRelation> relationMap = new HashMap<>();
        for(QuestionNoRelation relation : relationList){
            relationMap.put(relation.getId(), relation);
        }
        List<String> questionTypes = QuestionType.FromSubject(questionSubject);
        Map<String, UserDataDto> dtoMap = new HashMap<>();
        for(String questionType : questionTypes){
            UserDataDto dto = new UserDataDto();
            JSONObject placeMap = new JSONObject();
            JSONObject difficultMap = new JSONObject();

            Integer correctTime = 0;
            Integer incorrectTime = 0;

            List<QuestionNo> list = relationList.stream().filter((row)->row.getQuestion().getQuestionType().equals(questionType)).collect(Collectors.toList());
            PaperStat stat = questionNoService.statPaper(list);
            dto.setTotalCorrect(stat.getTotalCorrect());
            dto.setTotalNumber(stat.getTotalNumber());
            dto.setTotalTime(stat.getTotalTime());

            Collection questionNoIds = Transform.getIds(list, QuestionNo.class, "id");
            List<UserQuestion> userQuestionList = userQuestionService.listByQuestionWithTime(user.getId(), QuestionModule.BASE, questionNoIds, startTime, endTime);
            UserQuestionStat userQuestionStat = userQuestionService.statQuestion(userQuestionList);

            dto.setUserCorrect(userQuestionStat.getUserCorrect());
            dto.setUserNumber(userQuestionStat.getUserNumber());
            dto.setUserTime(userQuestionStat.getUserTime());

            for (UserQuestion userQuestion:userQuestionList){
                QuestionNoRelation relation = relationMap.get(userQuestion.getQuestionNoId());

                // 考点用时，以及正确度
                String placeKey = relation.getQuestion().getPlace();
                JSONObject place = placeMap.getJSONObject(placeKey);
                if (place == null){
                    place = new JSONObject();
                    place.put("key", placeKey);
                    place.put("userNumber", 1);
                    place.put("userCorrect", userQuestion.getIsCorrect());
                    place.put("userTime", userQuestion.getUserTime());
                    placeMap.put(placeKey, place);
                }else{
                    place.put("userNumber", place.getInteger("userNumber") + 1);
                    place.put("userCorrect", place.getInteger("userCorrect") + userQuestion.getIsCorrect());
                    place.put("userTime", place.getInteger("userTime") + userQuestion.getUserTime());
                }

                // 难度正确度
                String difficultKey = relation.getQuestion().getDifficult();
                JSONObject difficult = difficultMap.getJSONObject(difficultKey);
                if (difficult == null){
                    difficult = new JSONObject();
                    difficult.put("key", difficultKey);
                    difficult.put("userNumber", 1);
                    difficult.put("userCorrect", userQuestion.getIsCorrect());
                    difficult.put("totalNumber", relation.getTotalNumber());
                    difficult.put("totalCorrect", relation.getTotalCorrect());
                    difficultMap.put(difficultKey, difficult);
                }else{
                    difficult.put("userNumber", difficult.getInteger("userNumber") + 1);
                    difficult.put("userCorrect", difficult.getInteger("userCorrect") + userQuestion.getIsCorrect());
                    difficult.put("totalNumber", difficult.getInteger("totalNumber") + relation.getTotalNumber());
                    difficult.put("totalCorrect", difficult.getInteger("totalCorrect") + relation.getTotalCorrect());
                }

                if (userQuestion.getIsCorrect() > 0){
                    correctTime += userQuestion.getUserTime();
                }else{
                    incorrectTime += userQuestion.getUserTime();
                }
            }
            JSONArray difficult = new JSONArray();
            JSONArray place = new JSONArray();
            difficult.addAll(difficultMap.values());
            place.addAll(placeMap.values());
            dto.setDifficult(difficult);
            dto.setPlace(place);

            dto.setCorrectTime(correctTime);
            dto.setIncorrectTime(incorrectTime);
            dtoMap.put(questionType, dto);
        }

        return ResponseHelp.success(dtoMap);
    }

    @RequestMapping(value = "/collect/experience/add", method = RequestMethod.PUT)
    @ApiOperation(value = "添加心经收藏", notes = "添加心经收藏", httpMethod = "PUT")
    public Response<Boolean> addExperienceCollect(@RequestBody @Validated UserCollectExperienceDto dto)  {
        UserCollectExperience entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        userCollectExperienceService.addExperience(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/collect/experience/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "移除心经收藏", notes = "移除心经收藏", httpMethod = "DELETE")
    public Response<Boolean> deleteExperienceCollect(Integer experienceId)  {
        User user = (User) shiroHelp.getLoginUser();
        Boolean result = userCollectExperienceService.deleteExperience(user.getId(), experienceId);

        return ResponseHelp.success(result);
    }

    @RequestMapping(value = "/collect/experience/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取收藏心经列表", notes = "获取收藏心经列表", httpMethod = "GET")
    public Response<PageMessage<CourseExperience>> listExperienceCollect(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false, defaultValue = "id") String order, // collect_time, update_time
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session)  {
        User user = (User) shiroHelp.getLoginUser();
        Page<CourseExperience> p = courseExperienceService.listWithUser(page, size, user.getId(), startTime, endTime, order, DirectionStatus.ValueOf(direction));

        return ResponseHelp.success(p, page, size, p.getTotal());
    }

    @RequestMapping(value = "/collect/question/add", method = RequestMethod.PUT)
    @ApiOperation(value = "添加题目收藏", notes = "添加题目收藏", httpMethod = "PUT")
    public Response<Boolean> addQuestionCollect(@RequestBody @Validated UserCollectQuestionDto dto)  {
        UserCollectQuestion entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        switch (QuestionModule.ValueOf(dto.getQuestionModule())){
            case BASE:
                entity.setQuestionModule(QuestionModule.BASE.key);
                QuestionNo questionNo = questionNoService.get(dto.getQuestionNoId());
                entity.setQuestionId(questionNo.getQuestionId());
                entity.setQuestionNoId(questionNo.getId());
                break;
            case SENTENCE:
                entity.setQuestionModule(QuestionModule.SENTENCE.key);
                SentenceQuestion sentenceQuestion = sentenceQuestionService.get(dto.getQuestionNoId());
                entity.setQuestionId(sentenceQuestion.getQuestionId());
                entity.setQuestionNoId(sentenceQuestion.getId());
                break;
            case TEXTBOOK:
                entity.setQuestionModule(QuestionModule.TEXTBOOK.key);
                TextbookQuestion textbookQuestion = textbookQuestionService.get(dto.getQuestionNoId());
                entity.setQuestionId(textbookQuestion.getQuestionId());
                entity.setQuestionNoId(textbookQuestion.getId());
                break;
        }
        entity.setUserId(user.getId());
        userCollectQuestionService.addQuestion(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/collect/question/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "移除题目收藏", notes = "移除题目收藏", httpMethod = "DELETE")
    public Response<Boolean> deleteQuestionCollect(String questionModule, Integer questionNoId)  {
        User user = (User) shiroHelp.getLoginUser();
        Integer questionId = null;
        switch (QuestionModule.ValueOf(questionModule)){
            case BASE:
                QuestionNo questionNo = questionNoService.get(questionNoId);
                questionId = questionNo.getQuestionId();
                break;
            case SENTENCE:
                SentenceQuestion sentenceQuestion = sentenceQuestionService.get(questionNoId);
                questionId = sentenceQuestion.getQuestionId();
                break;
            case TEXTBOOK:
                TextbookQuestion textbookQuestion = textbookQuestionService.get(questionNoId);
                questionId = textbookQuestion.getQuestionId();
                break;
        }
        Boolean result = userCollectQuestionService.deleteQuestion(user.getId(), questionId);

        return ResponseHelp.success(result);
    }

    @RequestMapping(value = "/collect/question/bind", method = RequestMethod.POST)
    @ApiOperation(value = "收藏题目组卷", notes = "收藏题目组卷", httpMethod = "POST")
    public Response<UserPaper> bindQuestionCollect(@RequestBody @Validated UserCustomBindDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        UserPaper userPaper = questionFlowService.makePaper(
                user.getId(),
                QuestionModule.ValueOf(dto.getQuestionModule()),
                PaperOrigin.COLLECT,
                Arrays.stream(dto.getQuestionNoIds()).collect(Collectors.toList()),
                dto.getFilterTimes()
        );

        return ResponseHelp.success(userPaper);
    }

    @RequestMapping(value = "/collect/question/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取收藏题目列表", notes = "获取收藏题目列表", httpMethod = "GET")
    public Response<PageMessage<UserCollectQuestionInfoDto>> listQuestionCollect(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String[] questionTypes,
            @RequestParam(required = false) Integer[] structIds,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false) Boolean latest,
            @RequestParam(required = false) String year,
            @RequestParam(required = false) String order, // (pid asc, no asc), time, correct, question_type, latest_time
            HttpSession session)  {
        User user = (User) shiroHelp.getLoginUser();
        QuestionNoModule questionNoModule = QuestionNoModule.ValueOf(module);
        Page<UserCollectQuestion> p = null;
        if(questionNoModule == QuestionNoModule.EXERCISE){
            p = userCollectQuestionService.listExercise(page, size, user.getId(), keyword, questionTypes, structIds, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else if (questionNoModule == QuestionNoModule.EXAMINATION){
            Integer libraryId = null;
            if (latest != null){
                if (latest) {
                    TextbookLibrary textbookLibrary = textbookLibraryService.getLatest();
                    libraryId = textbookLibrary.getId();
                    year = null;
                }
            }
            p = userCollectQuestionService.listExamination(page, size, user.getId(), keyword, questionTypes, structIds, libraryId, year, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else{
            throw new ParameterException("参数逻辑错误");
        }
        List<UserCollectQuestionInfoDto> pr = Transform.convert(p, UserCollectQuestionInfoDto.class);

        // 获取题目信息
        Collection questionIds = Transform.getIds(pr, UserCollectQuestionInfoDto.class, "questionId");
        List<Question> questionList = questionService.select(questionIds);
        Transform.combine(pr, questionList, UserCollectQuestionInfoDto.class, "questionId", "question", Question.class, "id", QuestionExtendDto.class);

        List<UserCollectQuestionInfoDto> basePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.BASE.key)).collect(Collectors.toList());
        Collection baseQuestionNoIds = Transform.getIds(basePr, UserCollectQuestionInfoDto.class, "questionNoId");
        List<QuestionNo> baseQuestionNoList = questionNoService.select(baseQuestionNoIds);
        Transform.combine(basePr, baseQuestionNoList, UserCollectQuestionInfoDto.class, "questionNoId", "questionNo", QuestionNo.class, "id", QuestionNoExtendDto.class);

        List<UserCollectQuestionInfoDto> sentencePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.SENTENCE.key)).collect(Collectors.toList());
        Collection sentenceQuestionNoIds = Transform.getIds(sentencePr, UserCollectQuestionInfoDto.class, "questionNoId");
        List<SentenceQuestion> sentenceQuestionList = sentenceQuestionService.select(sentenceQuestionNoIds);
        Transform.combine(sentencePr, sentenceQuestionList, UserCollectQuestionInfoDto.class, "questionNoId", "questionNo", SentenceQuestion.class, "id", QuestionNoExtendDto.class);

        List<UserCollectQuestionInfoDto> textbookPr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.TEXTBOOK.key)).collect(Collectors.toList());
        Collection textbookQuestionNoIds = Transform.getIds(textbookPr, UserCollectQuestionInfoDto.class, "questionNoId");
        List<TextbookQuestion> textbookQuestionList = textbookQuestionService.select(textbookQuestionNoIds);
        Transform.combine(textbookPr, textbookQuestionList, UserCollectQuestionInfoDto.class, "questionNoId", "questionNo", TextbookQuestion.class, "id", QuestionNoExtendDto.class);

        // 绑定题目统计
        List<UserQuestion> userQuestionList = userQuestionService.listByQuestion(user.getId(), questionIds);
        Map<Object, UserQuestionStat> stats = userQuestionService.statQuestionMap(userQuestionList);
        Transform.combine(pr, stats, UserCollectQuestionInfoDto.class, "questionId", "stat");

        // 最近做题
        List<UserQuestion> lastList = userQuestionService.listWithLast(questionIds);
        Map lastMap = Transform.getMap(lastList, UserQuestion.class, "id", "createTime");
        Transform.combine(pr, lastMap, UserQuestionErrorInfoDto.class, "questionId", "latestTime");

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/error/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取错题列表", notes = "获取错题列表", httpMethod = "GET")
    public Response<PageMessage<UserQuestionErrorInfoDto>> listError(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String[] questionTypes,
            @RequestParam(required = false) Integer[] structIds,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false) Boolean latest,
            @RequestParam(required = false) String year,
            @RequestParam(required = false) String order // (pid asc, no asc), time, correct, question_type, latest_time
    )  {
        User user = (User) shiroHelp.getLoginUser();
        QuestionNoModule questionNoModule = QuestionNoModule.ValueOf(module);
        Page<UserQuestion> p = null;
        if(questionNoModule == QuestionNoModule.EXERCISE){
            p = userQuestionService.listExerciseError(page, size, user.getId(), keyword, questionTypes, structIds, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else if (questionNoModule == QuestionNoModule.EXAMINATION){
            Integer libraryId = null;
            if (latest != null){
                if (latest) {
                    TextbookLibrary textbookLibrary = textbookLibraryService.getLatest();
                    libraryId = textbookLibrary.getId();
                    year = null;
                }
            }
            p = userQuestionService.listExaminationError(page, size, user.getId(), keyword, questionTypes, structIds, libraryId, year, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else{
            throw new ParameterException("参数逻辑错误");
        }
        List<UserQuestionErrorInfoDto> pr = Transform.convert(p, UserQuestionErrorInfoDto.class);

        // 获取题目信息
        Collection questionIds = Transform.getIds(pr, UserQuestionErrorInfoDto.class, "questionId");
        List<Question> questionList = questionService.select(questionIds);
        Transform.combine(pr, questionList, UserQuestionErrorInfoDto.class, "questionId", "question", Question.class, "id", QuestionExtendDto.class);

        List<UserQuestionErrorInfoDto> basePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.BASE.key)).collect(Collectors.toList());
        Collection baseQuestionNoIds = Transform.getIds(basePr, UserQuestionErrorInfoDto.class, "questionNoId");
        List<QuestionNo> baseQuestionNoList = questionNoService.select(baseQuestionNoIds);
        Transform.combine(basePr, baseQuestionNoList, UserQuestionErrorInfoDto.class, "questionNoId", "questionNo", QuestionNo.class, "id", QuestionNoExtendDto.class);

        List<UserQuestionErrorInfoDto> sentencePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.SENTENCE.key)).collect(Collectors.toList());
        Collection sentenceQuestionNoIds = Transform.getIds(sentencePr, UserQuestionErrorInfoDto.class, "questionNoId");
        List<SentenceQuestion> sentenceQuestionList = sentenceQuestionService.select(sentenceQuestionNoIds);
        Transform.combine(sentencePr, sentenceQuestionList, UserQuestionErrorInfoDto.class, "questionNoId", "questionNo", SentenceQuestion.class, "id", QuestionNoExtendDto.class);

        List<UserQuestionErrorInfoDto> textbookPr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.TEXTBOOK.key)).collect(Collectors.toList());
        Collection textbookQuestionNoIds = Transform.getIds(textbookPr, UserQuestionErrorInfoDto.class, "questionNoId");
        List<TextbookQuestion> textbookQuestionList = textbookQuestionService.select(textbookQuestionNoIds);
        Transform.combine(textbookPr, textbookQuestionList, UserQuestionErrorInfoDto.class, "questionNoId", "questionNo", TextbookQuestion.class, "id", QuestionNoExtendDto.class);

        // 绑定题目统计
        List<UserQuestion> userQuestionList = userQuestionService.listByQuestion(user.getId(), questionIds);
        Map<Object, UserQuestionStat> stats = userQuestionService.statQuestionMap(userQuestionList);
        Transform.combine(pr, stats, UserQuestionErrorInfoDto.class, "questionId", "stat");

        // 最近做题
        List<UserQuestion> lastList = userQuestionService.listWithLast(questionIds);
        Map lastMap = Transform.getMap(lastList, UserQuestion.class, "id", "createTime");
        Transform.combine(pr, lastMap, UserQuestionErrorInfoDto.class, "questionId", "latestTime");

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/error/bind", method = RequestMethod.POST)
    @ApiOperation(value = "错题组卷", notes = "错题组卷", httpMethod = "POST")
    public Response<UserPaper> bindError(@RequestBody @Validated UserCustomBindDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        UserPaper userPaper = questionFlowService.makePaper(
                user.getId(),
                QuestionModule.ValueOf(dto.getQuestionModule()),
                PaperOrigin.ERROR,
                Arrays.stream(dto.getQuestionNoIds()).collect(Collectors.toList()),
                dto.getFilterTimes()
        );

        return ResponseHelp.success(userPaper);
    }

    @RequestMapping(value = "/error/clear", method = RequestMethod.POST)
    @ApiOperation(value = "错题移除", notes = "错题移除", httpMethod = "POST")
    public Response<Boolean> clearError(@RequestBody @Validated UserQuestionIdsDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        List<UserQuestion> questionList = userQuestionService.select(dto.getQuestionNoIds());
        userPaperQuestionService.addRemoveError(questionList);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/error/remove", method = RequestMethod.POST)
    @ApiOperation(value = "移除正确题", notes = "移除正确题", httpMethod = "POST")
    public Response<Boolean> removeError(@RequestBody @Validated ErrorReportDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        UserReport report = userReportService.get(dto.getUserReportId());
        if (report.getIsFinish() == 0){
            throw new ParameterException("试卷未完成");
        }
        List<UserQuestion> questionList = userQuestionService.listByReport(user.getId(), dto.getUserReportId());
        userPaperQuestionService.addRemoveError(questionList);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/note/question", method = RequestMethod.PUT)
    @ApiOperation(value = "更新题目笔记", notes = "更新题目笔记", httpMethod = "PUT")
    public Response<Boolean> updateNoteQuestion(@RequestBody @Validated UserNoteQuestionDto dto)  {
        UserNoteQuestion entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        switch (QuestionModule.ValueOf(dto.getQuestionModule())){
            case BASE:
                entity.setQuestionModule(QuestionModule.BASE.key);
                QuestionNo questionNo = questionNoService.get(dto.getQuestionNoId());
                entity.setQuestionId(questionNo.getQuestionId());
                entity.setQuestionNoId(questionNo.getId());
                break;
            case SENTENCE:
                entity.setQuestionModule(QuestionModule.SENTENCE.key);
                SentenceQuestion sentenceQuestion = sentenceQuestionService.get(dto.getQuestionNoId());
                entity.setQuestionId(sentenceQuestion.getQuestionId());
                entity.setQuestionNoId(sentenceQuestion.getId());
                break;
            case TEXTBOOK:
                entity.setQuestionModule(QuestionModule.TEXTBOOK.key);
                TextbookQuestion textbookQuestion = textbookQuestionService.get(dto.getQuestionNoId());
                entity.setQuestionId(textbookQuestion.getQuestionId());
                entity.setQuestionNoId(textbookQuestion.getId());
                break;
        }

        userNoteQuestionService.update(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/note/question/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取题目笔记列表", notes = "获取笔记列表", httpMethod = "GET")
    public Response<PageMessage<UserNoteQuestionInfoDto>> listNoteQuestion(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String[] questionTypes,
            @RequestParam(required = false) Integer[] structIds,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false) Boolean latest,
            @RequestParam(required = false) String year,
            @RequestParam(required = false) String order, // update_time
            HttpSession session)  {
        User user = (User) shiroHelp.getLoginUser();
        QuestionNoModule questionNoModule = QuestionNoModule.ValueOf(module);
        Page<UserNoteQuestion> p = null;
        if(questionNoModule == QuestionNoModule.EXERCISE){
            p = userNoteQuestionService.listExercise(page, size, user.getId(), keyword, questionTypes, structIds, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else if (questionNoModule == QuestionNoModule.EXAMINATION){
            Integer libraryId = null;
            if (latest != null){
                if (latest) {
                    TextbookLibrary textbookLibrary = textbookLibraryService.getLatest();
                    libraryId = textbookLibrary.getId();
                    year = null;
                }
            }
            p = userNoteQuestionService.listExamination(page, size, user.getId(), keyword, questionTypes, structIds, libraryId, year, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else{
            throw new ParameterException("参数逻辑错误");
        }
        List<UserNoteQuestionInfoDto> pr = Transform.convert(p, UserNoteQuestionInfoDto.class);

        // 获取题目信息
        Collection questionIds = Transform.getIds(pr, UserNoteQuestionInfoDto.class, "questionId");
        List<Question> questionList = questionService.select(questionIds);
        Transform.combine(pr, questionList, UserNoteQuestionInfoDto.class, "questionId", "question", Question.class, "id", QuestionExtendDto.class);

        List<UserNoteQuestionInfoDto> basePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.BASE.key)).collect(Collectors.toList());
        Collection baseQuestionNoIds = Transform.getIds(basePr, UserNoteQuestionInfoDto.class, "questionNoId");
        List<QuestionNo> baseQuestionNoList = questionNoService.select(baseQuestionNoIds);
        Transform.combine(basePr, baseQuestionNoList, UserNoteQuestionInfoDto.class, "questionNoId", "questionNo", QuestionNo.class, "id", QuestionNoExtendDto.class);

        List<UserNoteQuestionInfoDto> sentencePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.SENTENCE.key)).collect(Collectors.toList());
        Collection sentenceQuestionNoIds = Transform.getIds(sentencePr, UserNoteQuestionInfoDto.class, "questionNoId");
        List<SentenceQuestion> sentenceQuestionList = sentenceQuestionService.select(sentenceQuestionNoIds);
        Transform.combine(sentencePr, sentenceQuestionList, UserNoteQuestionInfoDto.class, "questionNoId", "questionNo", SentenceQuestion.class, "id", QuestionNoExtendDto.class);

        List<UserNoteQuestionInfoDto> textbookPr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.TEXTBOOK.key)).collect(Collectors.toList());
        Collection textbookQuestionNoIds = Transform.getIds(textbookPr, UserNoteQuestionInfoDto.class, "questionNoId");
        List<TextbookQuestion> textbookQuestionList = textbookQuestionService.select(textbookQuestionNoIds);
        Transform.combine(textbookPr, textbookQuestionList, UserNoteQuestionInfoDto.class, "questionNoId", "questionNo", TextbookQuestion.class, "id", QuestionNoExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/note/course", method = RequestMethod.PUT)
    @ApiOperation(value = "更新课程笔记", notes = "更新课程笔记", httpMethod = "PUT")
    public Response<Boolean> updateNoteCourse(@RequestBody @Validated UserNoteQuestionDto dto)  {
        UserNoteCourse entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        userNoteCourseService.update(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/report/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取报告列表", notes = "获取报告列表", httpMethod = "GET")
    public Response<PageMessage<UserPaperDto>> listReport(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String origin,
            @RequestParam(required = false) String[] questionTypes,
            @RequestParam(required = false) Integer[] structIds,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false) Boolean latest,
            @RequestParam(required = false) String year,
            @RequestParam(required = false) String[] courseModules,
            @RequestParam(required = false) String order, // title, latest_time,correct,time
            HttpSession session)  {
        User user = (User) shiroHelp.getLoginUser();
        PaperOrigin paperOrigin = PaperOrigin.ValueOf(origin);
        QuestionNoModule questionNoModule = QuestionNoModule.ValueOf(module);
        Page<UserPaper> p = null;
        if (questionNoModule != null && (paperOrigin == PaperOrigin.COLLECT || paperOrigin == PaperOrigin.ERROR)){
            p = userPaperService.list(page, size, user.getId(), keyword, paperOrigin, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else if(questionNoModule == QuestionNoModule.EXERCISE){
            p = userPaperService.listExercise(page, size, user.getId(), keyword, questionTypes, structIds, courseModules, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else if (questionNoModule == QuestionNoModule.EXAMINATION){
            Integer libraryId = null;
            if (latest != null){
                paperOrigin = PaperOrigin.TEXTBOOK;
                if (latest) {
                    TextbookLibrary textbookLibrary = textbookLibraryService.getLatest();
                    libraryId = textbookLibrary.getId();
                    year = null;
                }
            }
            p = userPaperService.listExamination(page, size, user.getId(), keyword, structIds, libraryId, year, startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else{
            throw new ParameterException("参数逻辑错误");
        }
        List<UserPaperDto> pr = Transform.convert(p, UserPaperDto.class);

        Collection paperIds = Transform.getIds(p, UserPaper.class, "id");
        // 绑定用户报告
        Map<Object, Collection<UserReport>> reportByPaper = userReportService.mapByPaper(paperIds);
        Transform.combine(pr, reportByPaper, UserPaperDto.class, "id", "reports", UserReportExtendDto.class);

        // 获取试卷统计信息
        List<UserPaperDto> basePr = pr.stream().filter((row)->QuestionModule.BASE == QuestionModule.WithPaper(PaperModule.ValueOf(row.getPaperModule()))).collect(Collectors.toList());
        Map<Integer, Integer[]> baseIdsMap = new HashMap<>();
        for(UserPaperDto paper : basePr){
            baseIdsMap.put(paper.getId(), paper.getQuestionNoIds());
        }
        Map baseStatMap = questionNoService.statPaperMap(baseIdsMap);
        Transform.combine(pr, baseStatMap, UserPaperDto.class, "id", "stat");

        List<UserPaperDto> sentencePr = pr.stream().filter((row)->QuestionModule.SENTENCE == QuestionModule.WithPaper(PaperModule.ValueOf(row.getPaperModule()))).collect(Collectors.toList());
        Map<Integer, Integer[]> sentenceIdsMap = new HashMap<>();
        for(UserPaperDto paper : sentencePr){
            sentenceIdsMap.put(paper.getId(), paper.getQuestionNoIds());
        }
        Map sentenceStatMap = sentenceQuestionService.statPaperMap(sentenceIdsMap);
        Transform.combine(pr, sentenceStatMap, UserPaperDto.class, "id", "stat");

        List<UserPaperDto> textbookPr = pr.stream().filter((row)->QuestionModule.TEXTBOOK == QuestionModule.WithPaper(PaperModule.ValueOf(row.getPaperModule()))).collect(Collectors.toList());
        Map<Integer, Integer[]> textbookIdsMap = new HashMap<>();
        for(UserPaperDto paper : textbookPr){
            textbookIdsMap.put(paper.getId(), paper.getQuestionNoIds());
        }
        Map textbookStatMap = textbookQuestionService.statPaperMap(textbookIdsMap);
        Transform.combine(pr, textbookStatMap, UserPaperDto.class, "id", "stat");

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/ask/question", method = RequestMethod.POST)
    @ApiOperation(value = "添加题目提问", notes = "添加题目提问", httpMethod = "POST")
    public Response<Boolean> addAskQuestion(@RequestBody @Validated UserAskQuestionDto dto)  {
        UserAskQuestion entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        PaperModule paperModule = PaperModule.ValueOf(dto.getPaperModule());
        QuestionModule questionModule = QuestionModule.WithPaper(paperModule);
        Question question;
        switch (questionModule){
            case BASE:
                entity.setQuestionModule(QuestionModule.BASE.key);
                QuestionNo questionNo = questionNoService.get(dto.getQuestionNoId());
                entity.setQuestionId(questionNo.getQuestionId());
                entity.setQuestionNoId(questionNo.getId());

                question = questionService.get(questionNo.getQuestionId());
                break;
            case SENTENCE:
                entity.setQuestionModule(QuestionModule.SENTENCE.key);
                SentenceQuestion sentenceQuestion = sentenceQuestionService.get(dto.getQuestionNoId());
                entity.setQuestionId(sentenceQuestion.getQuestionId());
                entity.setQuestionNoId(sentenceQuestion.getId());

                question = questionService.get(sentenceQuestion.getQuestionId());
                break;
            case TEXTBOOK:
                entity.setQuestionModule(QuestionModule.TEXTBOOK.key);
                TextbookQuestion textbookQuestion = textbookQuestionService.get(dto.getQuestionNoId());
                entity.setQuestionId(textbookQuestion.getQuestionId());
                entity.setQuestionNoId(textbookQuestion.getId());

                question = questionService.get(textbookQuestion.getQuestionId());
                break;
            default:
                throw new ParameterException("题目模块错误");
        }

        entity.setAskModule(AskModule.WithPaper(paperModule).key);
        Integer assignId = null;
        if (dto.getUserPaperId() != null && dto.getUserPaperId() > 0){
            UserPaper userPaper = userPaperService.get(dto.getUserPaperId());
            if(userPaper != null && userPaper.getPaperOrigin().equals(PaperOrigin.PREVIEW.key)){
                assignId = userPaper.getOriginId();
            }
        }
        Integer recordId = questionFlowService.questionRelationCourse(user.getId(), assignId, QuestionType.ValueOf(question.getQuestionType()));

        if (recordId != null){
            // 绑定提问权限
            entity.setRecordId(recordId);
            UserOrderRecord record = userOrderRecordService.get(recordId);
            entity.setAskTime(record.getAskTime());
            Date now = new Date();
            entity.setExpireTime(Tools.addHour(now, record.getAskTime() / 3600));
        }else{
            // todo 判断题目是否有提问权限
        }
        userAskQuestionService.add(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/ask/question/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "提问删除", httpMethod = "DELETE")
    public Response<Boolean> deleteAskQuestion(@RequestParam int id, HttpServletRequest request) {
        UserAskQuestion in = userAskQuestionService.get(id);
        User user = (User) shiroHelp.getLoginUser();
        if(in == null){
            throw new ParameterException("提问不存在");
        }
        if (!in.getUserId().equals(user.getId())){
            throw new ParameterException("提问不存在");
        }
        if (in.getAnswerStatus()== AskStatus.ANSWER.index){
            throw new ParameterException("提问已回答");
        }
        userAskQuestionService.delete(id);
        // 如果
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/ask/question/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取题目提问列表", notes = "获取题目提问列表", httpMethod = "GET")
    public Response<PageMessage<UserAskQuestionInfoDto>> listAskQuestion(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String[] questionTypes,
            @RequestParam(required = false) Integer[] structIds,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false) Integer askStatus,
            @RequestParam(required = false) Boolean latest,
            @RequestParam(required = false) String year,
            @RequestParam(required = false) String order, // create_time, answer_time
            HttpSession session)  {
        User user = (User) shiroHelp.getLoginUser();
        QuestionNoModule questionNoModule = QuestionNoModule.ValueOf(module);
        Page<UserAskQuestion> p = null;
        if(questionNoModule == QuestionNoModule.EXERCISE){
            p = userAskQuestionService.listExercise(page, size, user.getId(), keyword, questionTypes, structIds, AskStatus.ValueOf(askStatus),startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else if (questionNoModule == QuestionNoModule.EXAMINATION){
            Integer libraryId = null;
            if (latest != null){
                if (latest) {
                    TextbookLibrary textbookLibrary = textbookLibraryService.getLatest();
                    libraryId = textbookLibrary.getId();
                    year = null;
                }
            }
            p = userAskQuestionService.listExamination(page, size, user.getId(), keyword, questionTypes, structIds, libraryId, year, AskStatus.ValueOf(askStatus), startTime, endTime, order != null ? order.replace("|", " ") : null);
        }else{
            throw new ParameterException("参数逻辑错误");
        }
        List<UserAskQuestionInfoDto> pr = Transform.convert(p, UserAskQuestionInfoDto.class);

        // 获取题目信息
        Collection questionIds = Transform.getIds(pr, UserNoteQuestionInfoDto.class, "questionId");
        List<Question> questionList = questionService.select(questionIds);
        Transform.combine(pr, questionList, UserNoteQuestionInfoDto.class, "questionId", "question", Question.class, "id", QuestionExtendDto.class);

        List<UserAskQuestionInfoDto> basePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.BASE.key)).collect(Collectors.toList());
        Collection baseQuestionNoIds = Transform.getIds(basePr, UserAskQuestionInfoDto.class, "questionNoId");
        List<QuestionNo> baseQuestionNoList = questionNoService.select(baseQuestionNoIds);
        Transform.combine(basePr, baseQuestionNoList, UserAskQuestionInfoDto.class, "questionNoId", "questionNo", QuestionNo.class, "id", QuestionNoExtendDto.class);

        List<UserAskQuestionInfoDto> sentencePr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.SENTENCE.key)).collect(Collectors.toList());
        Collection sentenceQuestionNoIds = Transform.getIds(sentencePr, UserAskQuestionInfoDto.class, "questionNoId");
        List<SentenceQuestion> sentenceQuestionList = sentenceQuestionService.select(sentenceQuestionNoIds);
        Transform.combine(sentencePr, sentenceQuestionList, UserAskQuestionInfoDto.class, "questionNoId", "questionNo", SentenceQuestion.class, "id", QuestionNoExtendDto.class);

        List<UserAskQuestionInfoDto> textbookPr = pr.stream().filter((row)->row.getQuestionModule().equals(QuestionModule.TEXTBOOK.key)).collect(Collectors.toList());
        Collection textbookQuestionNoIds = Transform.getIds(textbookPr, UserAskQuestionInfoDto.class, "questionNoId");
        List<TextbookQuestion> textbookQuestionList = textbookQuestionService.select(textbookQuestionNoIds);
        Transform.combine(textbookPr, textbookQuestionList, UserAskQuestionInfoDto.class, "questionNoId", "questionNo", TextbookQuestion.class, "id", QuestionNoExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/ask/course", method = RequestMethod.POST)
    @ApiOperation(value = "添加课程提问", notes = "添加课程提问", httpMethod = "POST")
    public Response<Boolean> addAskCourse(@RequestBody @Validated UserAskCourseDto dto)  {
        UserAskCourse entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());

        UserCourse userCourse = courseExtendService.userCourse(user.getId(), dto.getCourseId());
        if (userCourse != null){
            // 绑定提问权限
            entity.setRecordId(userCourse.getRecordId());
            UserOrderRecord record = userOrderRecordService.get(userCourse.getRecordId());
            entity.setAskTime(record.getAskTime());
            Date now = new Date();
            entity.setExpireTime(Tools.addHour(now, record.getAskTime() / 3600));
        }else{
            throw new ParameterException("课程需开通后才能提问");
        }
        userAskCourseService.add(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/feedback/error/question", method = RequestMethod.POST)
    @ApiOperation(value = "添加题目勘误", notes = "添加勘误", httpMethod = "POST")
    public Response<Boolean> addFeedbackErrorQuestion(@RequestBody @Validated UserFeedbackErrorQuestionDto dto)  {
        UserFeedbackError entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        entity.setModule(FeedbackModule.QUESTION.key);
        entity.setStatus(0);

        Question question;
        switch (QuestionModule.ValueOf(dto.getQuestionModule())){
            case BASE:
                entity.setQuestionModule(QuestionModule.BASE.key);
                QuestionNo questionNo = questionNoService.get(dto.getQuestionNoId());
                entity.setModuleId(questionNo.getQuestionId());
                entity.setQuestionNoId(questionNo.getId());

                question = questionService.get(questionNo.getQuestionId());
                break;
            case SENTENCE:
                entity.setQuestionModule(QuestionModule.SENTENCE.key);
                SentenceQuestion sentenceQuestion = sentenceQuestionService.get(dto.getQuestionNoId());
                entity.setModuleId(sentenceQuestion.getQuestionId());
                entity.setQuestionNoId(sentenceQuestion.getId());

                question = questionService.get(sentenceQuestion.getQuestionId());
                break;
            case TEXTBOOK:
                entity.setQuestionModule(QuestionModule.SENTENCE.key);
                TextbookQuestion textbookQuestion = textbookQuestionService.get(dto.getQuestionNoId());
                entity.setModuleId(textbookQuestion.getQuestionId());
                entity.setQuestionNoId(textbookQuestion.getId());

                question = questionService.get(textbookQuestion.getQuestionId());
                break;
            default:
                throw new ParameterException("题目模块错误");
        }
        entity.setQuestionType(question.getQuestionType());
        userFeedbackErrorService.add(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/feedback/error/data", method = RequestMethod.POST)
    @ApiOperation(value = "添加资料勘误", notes = "添加勘误", httpMethod = "POST")
    public Response<Boolean> addFeedbackError(@RequestBody @Validated UserFeedbackErrorDataDto dto)  {
        UserFeedbackError entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        entity.setModule(FeedbackModule.DATA.key);
        entity.setModuleId(dto.getDataId());
        entity.setStatus(0);
        userFeedbackErrorService.add(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/faq", method = RequestMethod.POST)
    @ApiOperation(value = "添加faq", notes = "添加faq", httpMethod = "POST")
    public Response<Boolean> addFaq(@RequestBody @Validated FaqDto dto)  {
        Faq entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        entity.setMessage(1);
        // 取消邮箱发送
//        entity.setEmail(user.getEmail());
        faqService.add(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/comment", method = RequestMethod.POST)
    @ApiOperation(value = "添加评论", notes = "添加评论", httpMethod = "POST")
    public Response<Boolean> addComment(@RequestBody @Validated CommentDto dto)  {
        Comment entity = Transform.dtoToEntity(dto);
        User user = (User) shiroHelp.getLoginUser();
        entity.setUserId(user.getId());
        commentService.add(entity);

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/data/history", method = RequestMethod.GET)
    @ApiOperation(value = "资料更新记录", httpMethod = "GET")
    public Response<PageMessage<CourseDataHistoryInfoDto>> listDataHistory(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer dataId,
            HttpSession session) {
        User user = (User) shiroHelp.getLoginUser();

        Page<CourseDataHistory> p = courseDataHistoryService.listByUser(page, size, dataId, user.getId());
        List<CourseDataHistoryInfoDto> pr = Transform.convert(p, CourseDataHistoryInfoDto.class);

        // 绑定资料
        Collection dataIds = Transform.getIds(p, CourseDataHistory.class, "dataId");
        List<CourseData> dataList = courseDataService.select(dataIds);
        Transform.combine(pr, dataList, CourseDataHistoryInfoDto.class, "dataId", "data", CourseData.class, "id", CourseDataExtendDto.class);
        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/data/list", method = RequestMethod.GET)
    @ApiOperation(value = "购买的资料记录", httpMethod = "GET")
    public Response<PageMessage<CourseData>> listData(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer structId,
            @RequestParam(required = false) String dataType,
            @RequestParam(required = false, defaultValue = "id") String order, // latest_time, sale_number
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        User user = (User) shiroHelp.getLoginUser();

        Page<CourseData> p = courseDataService.listByUser(page, size, user.getId(), structId, DataType.ValueOf(dataType),order, DirectionStatus.ValueOf(direction));

        return ResponseHelp.success(p, page, size, p.getTotal());
    }

    @RequestMapping(value = "/course/list", method = RequestMethod.GET)
    @ApiOperation(value = "购买的课程记录", httpMethod = "GET")
    public Response<PageMessage<UserCourseDetailDto>> listCourse(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String courseModule,
            @RequestParam(required = false) Boolean isUsed,
            @RequestParam(required = false) Boolean isEnd,
            @RequestParam(required = false, defaultValue = "id") String order, // useEndTime desc
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        User user = (User) shiroHelp.getLoginUser();

        Page<UserOrderRecord> p = userOrderRecordService.listWithCourse(page, size, user.getId(), CourseModule.ValueOf(courseModule), isUsed, isEnd, order, DirectionStatus.ValueOf(direction));
        List<UserCourseDetailDto> pr = Transform.convert(p, UserCourseDetailDto.class);

        Collection recordIds = Transform.getIds(p, UserOrderRecord.class,"id");

        // 绑定课程
        Collection courseIds = Transform.getIds(p, UserOrderRecord.class, "productId");
        List<Course> courseList = courseService.select(courseIds);
        Transform.combine(pr, courseList, UserCourseDetailDto.class, "productId", "course", Course.class, "id", CourseExtendDto.class);

        // 绑定课时、预约、进度
        Map<Object, Collection<CourseNo>> courseNoMap = courseNoService.groupByCourseId(courseIds);
        Transform.combine(pr, courseNoMap, UserCourseDetailDto.class, "productId", "courseNos", CourseNoExtendDto.class);

        Map<Object, Collection<UserCourseAppointment>> appointmentMap = userCourseAppointmentService.groupByRecordId(recordIds);
        Transform.combine(pr, appointmentMap, UserCourseDetailDto.class, "productId", "appointments", UserCourseAppointmentExtendDto.class);

        Map<Object, Collection<UserCourseProgress>> progressMap = userCourseProgressService.groupByRecordId(recordIds);
        Map<Object, Collection<UserCourseRecord>> recordMap = userCourseRecordService.groupByRecordId(recordIds);
        for(UserCourseDetailDto dto : pr){
            Collection<UserCourseProgress> list = progressMap.get(dto.getId());
            if (list == null || list.size() == 0) continue;
            Collection<CourseNo> courseNos = courseNoMap.get(dto.getProductId());
            dto.setCurrentNo(courseExtendService.computeCourseNoCurrent(courseNos, list));
            dto.setTotalDays(courseExtendService.computeCourseDay(recordMap.get(dto.getId())));
        }

        // 获取每个科目的所有作业
        Map<Object, Collection<UserPreviewPaperRelation>> previewMap = previewService.groupByCourseId(user.getId(), recordIds, 1000);
        Transform.combine(pr, previewMap, UserCourseDetailDto.class, "productId", "papers", UserPaperBaseExtendDto.class);
        for(UserCourseDetailDto dto : pr){
            Collection<UserPreviewPaperRelation> list = previewMap.get(dto.getId());
            if (list == null || list.size() == 0) continue;
            int finish = 0;
            for(UserPreviewPaperRelation relation : list){
                if (relation.getPaper() == null) continue;
                UserPaper paper = relation.getPaper();
                if (paper.getTimes() > 0){
                    finish += 1;
                }
            }
            dto.setPreviewProgress(finish * 100 / list.size());
        }

        // 绑定老师
        Collection teacherIds = Transform.getIds(p, UserOrderRecord.class, "teacherId");
        List<CourseTeacher> teacherList = courseTeacherService.select(teacherIds);
        Transform.combine(pr, teacherList, UserCourseDetailDto.class, "teacherId", "teacher", CourseTeacher.class, "id", CourseTeacherExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/course/suspend", method = RequestMethod.POST)
    @ApiOperation(value = "申请停课", notes = "申请停课", httpMethod = "POST")
    public Response<Boolean> suspendCourse(@RequestBody @Validated CourseSuspendDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        courseExtendService.suspendCourse(user.getId(), dto.getRecordId());

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/restore", method = RequestMethod.POST)
    @ApiOperation(value = "恢复停课", notes = "恢复停课", httpMethod = "POST")
    public Response<Boolean> restoreCourse(@RequestBody @Validated CourseRestoreDto dto)  {
        User user = (User) shiroHelp.getLoginUser();

        courseExtendService.restoreCourse(user.getId(), dto.getRecordId());

        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/time", method = RequestMethod.GET)
    @ApiOperation(value = "时间表", notes = "时间表", httpMethod = "GET")
    public Response<List<UserCourseTimeDto>> timeCourse(int id)  {
        User user = (User) shiroHelp.getLoginUser();
        List<UserCourseTimeDto> dtos = new ArrayList<>();

        UserOrderRecord record = userOrderRecordService.get(id);
        if (record == null){
            throw new ParameterException("记录不存在");
        }
        if (!record.getUserId().equals(user.getId())){
            throw new ParameterException("记录不存在");
        }
        Integer courseId = record.getProductId();

        // 获取停课记录
        Date suspend = record.getSuspendTime();
        if (suspend != null){
            Date restore = record.getRestoreTime();
            if (restore == null) restore = new Date();

            while(suspend.before(restore)){
                UserCourseTimeDto dto = new UserCourseTimeDto();
                dto.setType("stop");
                dto.setDay(Tools.day(suspend));
                dtos.add(dto);
                suspend = Tools.addDate(suspend, 1);
            }
        }
        List<Long> tmpList = new ArrayList<>();

        // 获取听课记录
        List<UserCourseRecord> userCourseRecordList = userCourseRecordService.allWithRecord(id);
        tmpList.clear();
        for(UserCourseRecord userCourseRecord:userCourseRecordList){
            Date day = Tools.day(userCourseRecord.getCreateTime());
            if (!tmpList.contains(day.getTime())){
                tmpList.add(day.getTime());

                UserCourseTimeDto dto = new UserCourseTimeDto();
                dto.setType("course");
                dto.setDay(day);
                dtos.add(dto);
            }
        }

        // 预习作业
        List<CourseNo> courseNoList = courseNoService.allCourse(courseId);
        Collection courseNoIds = Transform.getIds(courseNoList, CourseNo.class, "id");
        List<PreviewAssign> previewAssignList = previewAssignService.listByCourseNos(courseId, courseNoIds);
        Collection assignIds = Transform.getIds(previewAssignList, PreviewAssign.class, "id");
        List<UserPaper> userPaperList = userPaperService.listWithCourse(user.getId(), assignIds, id);
        Collection paperIds = Transform.getIds(userPaperList, UserPaper.class, "id");
        List<UserReport> userReportList = userReportService.listByPaper(paperIds);
        tmpList.clear();
        for(UserReport userReport:userReportList){
            Date day = Tools.day(userReport.getCreateTime());
            if (!tmpList.contains(day.getTime())){
                tmpList.add(day.getTime());

                UserCourseTimeDto dto = new UserCourseTimeDto();
                dto.setType("preview");
                dto.setDay(day);
                dtos.add(dto);
            }
        }

        return ResponseHelp.success(dtos);
    }
}