全部代码和数据库

无关风月

2024-12-31 52461f1688e83970d4aa3aa6b835bdf7719f5769

 ruoyi-service/ruoyi-study/src/main/java/com/ruoyi/study/controller/TStudyController.java

@@ -26,6 +26,7 @@
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

@@ -82,6 +83,70 @@
    @Resource
    private ITUserPresentRecordService userPresentRecordService;

    @PostMapping("/testAddData")
    @ApiOperation(value = "测试分片", tags = {"测试分片"})
    public R<Object> testAddData() {
        TIntegralRecord tIntegralRecord = new TIntegralRecord();
        tIntegralRecord.setIntegral("1");
        tIntegralRecord.setMethod("1");
        tIntegralRecord.setUserId(23);
        tIntegralRecord.setGameId(1);
        tIntegralRecord.setGameDifficulty(1);
        tIntegralRecord.setStoryId(1);
        tIntegralRecord.setStoryType(1);
        integralRecordService.save(tIntegralRecord);
        TGameRecord tGameRecord = new TGameRecord();
        tGameRecord.setUserId(33);
        tGameRecord.setAccuracy(0);
        tGameRecord.setGameName("");
        tGameRecord.setUseTime(0);
        tGameRecord.setUseTime1("");
        tGameRecord.setGameId(0);
        tGameRecord.setGameDifficulty(0);
        tGameRecord.setTime("");
        tGameRecord.setDisabled(false);
        tGameRecord.setCreateBy("");
        tGameRecord.setCreateTime(new Date());
        tGameRecord.setUpdateBy("");
        tGameRecord.setUpdateTime(new Date());
        gameRecordService.save(tGameRecord);
        TSubjectRecord tSubjectRecord = new TSubjectRecord();
        tSubjectRecord.setUserId(22);
        tSubjectRecord.setWeek(0);
        tSubjectRecord.setDay(0);
        tSubjectRecord.setBeforeSubject("");
        tSubjectRecord.setType(0);
        tSubjectRecord.setCompleteSubject("");
        tSubjectRecord.setAnswerNumber(0);
        tSubjectRecord.setCorrectNumber(0);
        tSubjectRecord.setDisabled(false);
        tSubjectRecord.setCreateBy("");
        tSubjectRecord.setCreateTime(new Date());
        tSubjectRecord.setUpdateBy("");
        tSubjectRecord.setUpdateTime(new Date());
        subjectRecordService.save(tSubjectRecord);
        TUserPresentRecord tUserPresentRecord = new TUserPresentRecord();
        tUserPresentRecord.setUserId(44);
        tUserPresentRecord.setPresentTime(new Date());
        tUserPresentRecord.setIsDelete(0);
        userPresentRecordService.save(tUserPresentRecord);

        TUserStudyRecord tUserStudyRecord = new TUserStudyRecord();
        tUserStudyRecord.setUserId(17);
        tUserStudyRecord.setQuarter(0);
        tUserStudyRecord.setWeek(0);
        tUserStudyRecord.setDay(0);
        tUserStudyRecord.setObtainedIntegral(0);
        tUserStudyRecord.setType(0);
        tUserStudyRecord.setStudyType(0);
        tUserStudyRecord.setStoryId(0);
        studyRecordService.save(tUserStudyRecord);

        return R.ok();
    }

    @Autowired
    private ICategoryService categoryService;
    @PostMapping("/storyList")
//    @ApiOperation(value = "配置学习类型选择故事", tags = {"题目管理"})
    public R<PageInfo<TStory>> storyList(@RequestBody ChoiceStory query) {
@@ -90,6 +155,22 @@
        if (StringUtils.hasLength(query.getName())) {
            wrapper.like("name", query.getName());
        }
        if (StringUtils.hasLength(query.getCategoryName())){
            // 查询分类id包含的
            List<Integer> collect = categoryService.lambdaQuery().eq(TCategory::getState, 2)
                    .eq(TCategory::getType,1)
                    .like(TCategory::getName, query.getCategoryName()).list()
                    .stream().map(TCategory::getId).collect(Collectors.toList());// 查询分类id包含的
            List<Integer> collect2 = categoryService.lambdaQuery().eq(TCategory::getState, 2)
                    .eq(TCategory::getType,2)
                    .like(TCategory::getName, query.getCategoryName()).list()
                    .stream().map(TCategory::getParentId).collect(Collectors.toList());
            collect.addAll(collect2);
            if (collect.isEmpty()){
                collect.add(-1);
            }
            wrapper.in("firstCategory", collect);
        }
        if (StringUtils.hasLength(query.getEnglish())) {
            wrapper.like("english", query.getEnglish());
        }
@@ -97,22 +178,33 @@
            wrapper.like("type", query.getType());
        }
        wrapper.eq("state", 1);
        List<TStory> tStories = new ArrayList<>();

        switch (query.getStoryType()) {
            case 2:
                List<TStory> list = storyService.list(wrapper);
                List<TStory> tSubjects = new ArrayList<>();
                for (TStory tSubject : list) {
                    if (!tSubject.getError().isEmpty()) {
                        tSubjects.add(tSubject);
                    TCategory first = categoryService.getById(tSubject.getFirstCategory());

                    TCategory second = categoryService.getById(tSubject.getSecondCategory());
                    if (first!=null&& second!=null){
                        tSubject.setCategoryName(first.getName()+"-"+second.getName());
                    }
                }
                res.setRecords(tSubjects);
                res.setTotal(tSubjects.size());
                res.setRecords(list);
                res.setTotal(list.size());
                return R.ok(res);
            case 1:
                // 查询出error字段不为空的数据
                wrapper.isNotNull("error");
                List<TStory> list1 = storyService.list(wrapper);
                for (TStory tStory : list1) {
                    TCategory first = categoryService.getById(tStory.getFirstCategory());
                    TCategory second = categoryService.getById(tStory.getSecondCategory());
                    if (first!=null&& second!=null){
                        tStory.setCategoryName(first.getName()+"-"+second.getName());
                    }
                }
                res.setRecords(list1);
                res.setTotal(list1.size());
                return R.ok(res);
@@ -132,6 +224,22 @@
        if (StringUtils.hasLength(query.getName())) {
            wrapper.like("name", query.getName());
        }
        if (StringUtils.hasLength(query.getCategoryName())){
            // 查询分类id包含的
            List<Integer> collect = categoryService.lambdaQuery().eq(TCategory::getState, 1)
                    .eq(TCategory::getType,1)
                    .like(TCategory::getName, query.getCategoryName()).list()
                    .stream().map(TCategory::getId).collect(Collectors.toList());// 查询分类id包含的
            List<Integer> collect2 = categoryService.lambdaQuery().eq(TCategory::getState, 1)
                    .eq(TCategory::getType,2)
                    .like(TCategory::getName, query.getCategoryName()).list()
                    .stream().map(TCategory::getParentId).collect(Collectors.toList());
            collect.addAll(collect2);
            if (collect.isEmpty()){
                collect.add(-1);
            }
            wrapper.in("firstCategory", collect);
        }
        if (StringUtils.hasLength(query.getEnglish())) {
            wrapper.like("english", query.getEnglish());
        }
@@ -142,6 +250,15 @@
        switch (query.getStudyType()) {
            case 1:
                List<TSubject> list = subjectService.list(wrapper);
                for (TSubject tSubject : list) {
                    TCategory first = categoryService.getById(tSubject.getFirstCategory());

                    TCategory second = categoryService.getById(tSubject.getSecondCategory());

                    if (first!=null&&second!=null){
                        tSubject.setCategoryName(first.getName()+"-"+second.getName());
                    }
                }
                res.setRecords(list);
                res.setTotal(list.size());
                return R.ok(res);
@@ -151,6 +268,13 @@
                List<TSubject> list1 = subjectService.list(wrapper);
                List<TSubject> tSubjects = new ArrayList<>();
                for (TSubject tSubject : list1) {
                    TCategory first = categoryService.getById(tSubject.getFirstCategory());

                    TCategory second = categoryService.getById(tSubject.getSecondCategory());

                    if (first!=null&&second!=null){
                        tSubject.setCategoryName(first.getName()+"-"+second.getName());
                    }
                    if (!tSubject.getError().isEmpty()) {
                        tSubjects.add(tSubject);
                    }
@@ -160,6 +284,14 @@
                return R.ok(res);
            case 3:
                List<TSubject> list2 = subjectService.list(wrapper);
                for (TSubject tSubject : list2) {
                    TCategory first = categoryService.getById(tSubject.getFirstCategory());
                    TCategory second = categoryService.getById(tSubject.getSecondCategory());

                    if (first!=null&&second!=null){
                        tSubject.setCategoryName(first.getName()+"-"+second.getName());
                    }
                }
                res.setRecords(list2);
                res.setTotal(list2.size());
                return R.ok(res);
@@ -169,6 +301,12 @@
                List<TSubject> list3 = subjectService.list(wrapper);
                List<TSubject> tSubjects3 = new ArrayList<>();
                for (TSubject tSubject : list3) {
                    TCategory first = categoryService.getById(tSubject.getFirstCategory());

                    TCategory second = categoryService.getById(tSubject.getSecondCategory());
                    if (first!=null&&second!=null){
                        tSubject.setCategoryName(first.getName()+"-"+second.getName());
                    }
                    if (!tSubject.getError().isEmpty()) {
                        tSubjects3.add(tSubject);
                    }
@@ -178,6 +316,14 @@
                return R.ok(res);
            case 5:
                List<TSubject> list4 = subjectService.list(wrapper);
                for (TSubject tSubject : list4) {
                    TCategory first = categoryService.getById(tSubject.getFirstCategory());

                    TCategory second = categoryService.getById(tSubject.getSecondCategory());
                    if (first!=null&&second!=null){
                        tSubject.setCategoryName(first.getName()+"-"+second.getName());
                    }
                }
                res.setRecords(list4);
                res.setTotal(list4.size());
                return R.ok(res);
@@ -213,6 +359,21 @@
                    .eq("studyId", one.getId())
                    .eq("week", week));
            if (studyId != null) {
                // 判断当前周目配置的题目数量
                List<String> subjectId = getSubjectId(week);
                List<String> newSubjectId = subjectId.stream().map(data -> {
                    if (data.startsWith(Constants.REDUCE)) {
                        data = data.replace(Constants.REDUCE, Constants.EMPTY_STR);
                    }
                    return data;
                }).distinct().collect(Collectors.toList());
                // 判断周目下题目是否足够
                if (newSubjectId.size() < game.getCount()) {
                    return R.fail("超级听力：当前周目下day1 - day5题目不足！");
                }
                if (newSubjectId.size() < game.getAnswerCount()) {
                    return R.fail("超级记忆：当前周目下day1 - day5题目不足！");
                }
                studyId.setWeek(dto.getWeek());
                studyId.setStudyId(one.getId());
                studyId.setCount(game.getCount());
@@ -225,6 +386,21 @@
                studyId.setAnswerRate(game.getAnswerRate());
                gameService.updateById(studyId);
            } else {
                // 判断当前周目配置的题目数量
                List<String> subjectId = getSubjectId(week);
                List<String> newSubjectId = subjectId.stream().map(data -> {
                    if (data.startsWith(Constants.REDUCE)) {
                        data = data.replace(Constants.REDUCE, Constants.EMPTY_STR);
                    }
                    return data;
                }).distinct().collect(Collectors.toList());
                // 判断周目下题目是否足够
                if (newSubjectId.size() < game.getCount()) {
                    return R.fail("超级听力：当前周目下day1 - day5题目不足！");
                }
                if (newSubjectId.size() < game.getAnswerCount()) {
                    return R.fail("超级记忆：当前周目下day1 - day5题目不足！");
                }
                TGame tGame = new TGame();
                tGame.setWeek(dto.getWeek());
                tGame.setAnswerRate(game.getAnswerRate());
@@ -702,6 +878,22 @@
    }

    /**
     * 获取当前季度游戏难度
     */
    @GetMapping("/userGameDifficulty")
    @ApiOperation(value = "获取当前季度游戏难度", tags = {"学习端-首页"})
    public R<Integer> userGameDifficulty(@RequestParam Integer week) {
        LoginUserParent loginStudy = tokenService.getLoginUserStudy();
        if (null == loginStudy) {
            return R.tokenError("登录失效！");
        }
        Integer userid = loginStudy.getUserid();
        TUserStudy studyRecord = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, userid)
                .eq(TUserStudy::getDisabled, 0).one();
        return R.ok(studyService.userGameDifficulty(studyRecord, week));
    }

    /**
     * 首次页面加载时调用,获取学习进度及学习时长等信息
     *
     * @param week 周目
@@ -736,6 +928,28 @@
            int sum = gameRecordList.stream().map(TGameRecord::getUseTime).mapToInt(Integer::intValue).sum();
            Integer totalStudy = studyRecord.getTotalStudy();
            studyRecord.setTotalStudy(Math.round((float) (totalStudy + sum) / 3600));
            studyRecord = studyService.studySchedule(studyRecord, week);
            // 数据库保存的是已完成的学习进度，返回前端时需要转换为剩余学习进度
            Integer look = studyRecord.getLook();
            if (look != 100 && look != -1) {
                studyRecord.setLook(100 - look);
            }
            Integer pair = studyRecord.getPair();
            if (pair != 100 && pair != -1) {
                studyRecord.setPair(100 - pair);
            }
            Integer answer = studyRecord.getAnswer();
            if (answer != 100 && answer != -1) {
                studyRecord.setAnswer(100 - answer);
            }
            Integer induction = studyRecord.getInduction();
            if (induction != 100 && induction != -1) {
                studyRecord.setInduction(100 - induction);
            }
            Integer listen = studyRecord.getListen();
            if (listen != 100 && listen != -1) {
                studyRecord.setListen(100 - listen);
            }
        }
        return R.ok(studyRecord);
    }
@@ -809,7 +1023,7 @@
            data.setIsDelete(0);
            result = result && userPresentRecordService.save(data);
        } else {
            if (System.currentTimeMillis() - record.getPresentTime().getTime() >= 10 * 60 * 1000) {
            if (System.currentTimeMillis() - record.getPresentTime().getTime() >= (long) Integer.parseInt(sysSet.getTime()) * 60 * 1000) {
                // 赠送积分
                result = userService.lambdaUpdate()
                        .set(TUser::getIntegral, user.getIntegral() + Integer.parseInt(integral))
@@ -820,6 +1034,12 @@
                data.setPresentTime(new Date());
                data.setIsDelete(0);
                result = result && userPresentRecordService.save(data);
                // 生成积分明细
                TIntegralRecord integralRecord = new TIntegralRecord();
                integralRecord.setIntegral(sysSet.getIntegral());
                integralRecord.setMethod(Constants.ONLINE_DURATION);
                integralRecord.setUserId(loginStudy.getUserid());
                result = result && integralRecordService.save(integralRecord);
            }
        }
        return R.ok(result);
@@ -852,20 +1072,16 @@
        // 返回结果
        SubjectRecordResultVO result;
        if (null != subjectRecord) {
            subjectRecordService.lambdaUpdate().set(TSubjectRecord::getDisabled, 1)
                    .eq(TSubjectRecord::getId, subjectRecord.getId()).update();
            // 题组id
            /*// 题组id
            List<Integer> teamIds = Arrays.stream(subjectRecord.getBeforeSubject().split(",")).map(Integer::parseInt)
                    .collect(Collectors.toList());
            // 题目id
            List<Integer> topicIds = Arrays.stream(subjectRecord.getCompleteSubject().split(",")).map(Integer::parseInt)
                    .collect(Collectors.toList());
            result = new SubjectRecordResultVO(teamIds, topicIds, subjectRecord.getAnswerNumber(), subjectRecord.getCorrectNumber());
                    .collect(Collectors.toList());*/
            result = new SubjectRecordResultVO(null, null, subjectRecord.getAnswerNumber(), subjectRecord.getCorrectNumber(), subjectRecord.getSchedule());
        } else {
            result = null;
        }
        subjectRecordService.lambdaUpdate().set(TSubjectRecord::getDisabled, 0)
                .eq(TSubjectRecord::getUserId, loginStudy.getUserid()).update();
        return R.ok(result);
    }

@@ -879,7 +1095,18 @@
        if (null == loginStudy) {
            return R.tokenError("登录失效！");
        }
        // 退出学习如果已经存在中途学习记录，则删除记录，保存新学习记录
        Integer userid = loginStudy.getUserid();
        TSubjectRecord subjectRecord = subjectRecordService.lambdaQuery()
                .eq(TSubjectRecord::getUserId, userid)
                .eq(TSubjectRecord::getWeek, exitLearn.getWeek())
                .eq(TSubjectRecord::getDay, exitLearn.getDay())
                .eq(TSubjectRecord::getType, exitLearn.getType())
                .eq(TSubjectRecord::getDisabled, 0)
                .one();
        if (null != subjectRecord) {
            subjectRecordService.removeById(subjectRecord);
        }
        // 判断当前week和day是否已完成学习
        TUserStudy userStudy = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, userid)
                .eq(TUserStudy::getDisabled, 0).one();
@@ -889,58 +1116,80 @@
        Integer quarter = exitLearn.getQuarter();
        Integer week = exitLearn.getWeek();
        Integer day = exitLearn.getDay();
        int schedule = exitLearn.getSchedule() == null ? 0 : exitLearn.getSchedule();
        int schedule = exitLearn.getSchedule() - 1;
        if (userStudy.getWeek().equals(exitLearn.getWeek()) && userStudy.getDay().equals(exitLearn.getDay())) {
            // 计算完成率
            Integer type = exitLearn.getType();
            // 更新用户学习完成率
            if (Constants.ONE.equals(type)) {
                // 听音选图
                List<TStudyListen> studyListens = studyListenService.listenSelectPicture(quarter, week, day);
                int item = 0;
                for (TStudyListen studyListen : studyListens) {
                    item += studyListen.getSubject().split(",").length;
                }
                int i = (int) ((double) (exitLearn.getTopicIds().split(",").length / item) * 100);
                if (i > userStudy.getListen()) {
                    userStudy.setListen(100 - i);
                if (userStudy.getListen() != 100) {
                    if (1 == exitLearn.getSchedule()) {
                        userStudy.setListen(Constants.BURDEN_ONE);
                    } else {
                        // 听音选图
                        List<TStudyListen> studyListens = studyListenService.listenSelectPicture(quarter, week, day);
                        int item = 0;
                        for (TStudyListen studyListen : studyListens) {
                            item += studyListen.getSubject().split(",").length;
                        }
                        int i = (int) (((double) schedule / item) * 100);
                        userStudy.setListen(i);
                    }
                }
            } else if (Constants.TWO.equals(type)) {
                // 看图选音
                List<TStudyLook> lookList = studyLookService.pictureSelectVoice(quarter, week, day);
                if (!lookList.isEmpty()) {
                    int item = lookList.size();
                    int i = (int) ((double) (schedule / item)) * 100;
                    if (i > userStudy.getLook()) {
                        userStudy.setLook(100 - i);
                if (userStudy.getLook() != 100) {
                    if (1 == exitLearn.getSchedule()) {
                        userStudy.setLook(Constants.BURDEN_ONE);
                    } else {
                        // 看图选音
                        List<TStudyLook> lookList = studyLookService.pictureSelectVoice(quarter, week, day);
                        if (!lookList.isEmpty()) {
                            int item = lookList.size();
                            int i = (int) (((double) schedule / item) * 100);
                            userStudy.setLook(i);
                        }
                    }
                }
            } else if (Constants.THREE.equals(type)) {
                // 归纳排除
                List<TStudyInduction> inductionList = studyInductionService.induceExclude(quarter, week, day);
                if (!inductionList.isEmpty()) {
                    int item = inductionList.size();
                    int i = (int) ((double) (schedule / item)) * 100;
                    if (i > userStudy.getInduction()) {
                        userStudy.setInduction(100 - i);
                if (userStudy.getInduction() != 100) {
                    if (1 == exitLearn.getSchedule()) {
                        userStudy.setInduction(Constants.BURDEN_ONE);
                    } else {
                        // 归纳排除
                        List<TStudyInduction> inductionList = studyInductionService.induceExclude(quarter, week, day);
                        if (!inductionList.isEmpty()) {
                            int item = inductionList.size();
                            int i = (int) (((double) schedule / item) * 100);
                            userStudy.setInduction(i);
                        }
                    }
                }
            } else if (Constants.FOUR.equals(type)) {
                // 有问有答
                List<TStudyAnswer> answerList = studyAnswerService.questionsAndAnswers(quarter, week, day);
                if (answerList.size() % Constants.TWO == Constants.ZERO) {
                    int i = (int) ((double) (schedule / (answerList.size() / 2))) * 100;
                    if (i > userStudy.getAnswer()) {
                        userStudy.setAnswer(100 - i);
                if (userStudy.getAnswer() != 100) {
                    if (1 == exitLearn.getSchedule()) {
                        userStudy.setAnswer(Constants.BURDEN_ONE);
                    } else {
                        // 有问有答
                        List<TStudyAnswer> answerList = studyAnswerService.questionsAndAnswers(quarter, week, day);
                        if (answerList.size() % Constants.TWO == Constants.ZERO) {
                            int i = (int) (((double) schedule / (answerList.size() / 2)) * 100);
                            userStudy.setAnswer(i);
                        }
                    }
                }
            } else if (Constants.FIVE.equals(type)) {
                // 音图相配
                List<TStudyPair> pairList = studyPairService.pictureMateVoice(quarter, week, day);
                int item = pairList.size();
                int i = (int) ((double) (schedule / item)) * 100;
                if (i > userStudy.getPair()) {
                    userStudy.setPair(100 - i);
                if (userStudy.getPair() != 100) {
                    if (1 == exitLearn.getSchedule()) {
                        userStudy.setPair(Constants.BURDEN_ONE);
                    } else {
                        // 音图相配
                        List<TStudyPair> pairList = studyPairService.pictureMateVoice(quarter, week, day);
                        if (!pairList.isEmpty()) {
                            int item = pairList.size();
                            int i = (int) (((double) schedule / item) * 100);
                            userStudy.setPair(i);
                        }
                    }
                }
            }
        }
@@ -951,6 +1200,31 @@
        userStudy.setMonthStudy(userStudy.getMonthStudy() + exitLearn.getStudyTime());
        userStudyService.updateById(userStudy);
        return R.ok(subjectRecordService.exitLearning(exitLearn, userid));
    }

    /**
     * 退出游戏/故事学习
     */
    @GetMapping("/exitGameOrStory")
    @ApiOperation(value = "退出游戏/故事学习", tags = {"学习端-题目"})
    public R<Boolean> exitGameOrStory(@RequestParam("studyTime") Integer studyTime) {
        LoginUserParent loginStudy = tokenService.getLoginUserStudy();
        if (null == loginStudy) {
            return R.tokenError("登录失效！");
        }
        Integer userid = loginStudy.getUserid();
        // 判断当前week和day是否已完成学习
        TUserStudy userStudy = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, userid)
                .eq(TUserStudy::getDisabled, 0).one();
        if (null == userStudy) {
            userStudy = createUserStudy(userid);
        }
        // 学习时长更新
        userStudy.setTotalStudy(userStudy.getTotalStudy() + studyTime);
        userStudy.setTodayStudy(userStudy.getTodayStudy() + studyTime);
        userStudy.setWeekStudy(userStudy.getWeekStudy() + studyTime);
        userStudy.setMonthStudy(userStudy.getMonthStudy() + studyTime);
        return R.ok(userStudyService.updateById(userStudy));
    }

    /**
@@ -1123,7 +1397,18 @@
        // 登录用户id
        Integer userId = userStudy.getUserid();
        // 判断是否已完成该题组
        boolean update = true;
        boolean update;
        // 清除中途退出记录
        TSubjectRecord subjectRecord = subjectRecordService.lambdaQuery()
                .eq(TSubjectRecord::getUserId, userId)
                .eq(TSubjectRecord::getWeek, completeStudy.getWeek())
                .eq(TSubjectRecord::getDay, completeStudy.getDay())
                .eq(TSubjectRecord::getType, completeStudy.getType())
                .eq(TSubjectRecord::getDisabled, 0)
                .one();
        if (null != subjectRecord) {
            subjectRecordService.removeById(subjectRecord);
        }
        List<String> studyIds = Arrays.stream(completeStudy.getStudyIds().split(","))
                .collect(Collectors.toList());
        Integer type = completeStudy.getType();
@@ -1240,6 +1525,10 @@
            @ApiImplicitParam(value = "所属周目", name = "week", dataType = "Integer", required = true)
    })
    public R<StudyGameMemoryVO> gameMemory(@RequestParam Integer quarter, @RequestParam Integer week) {
        LoginUserParent userStudy = tokenService.getLoginUserStudy();
        if (null == userStudy) {
            return R.tokenError("登录失效！");
        }
        TGame game = gameService.gameHearing(quarter, week);
        if (null == game) {
            throw new GlobalException("当前季度该周目暂无配置游戏数据！");
@@ -1254,6 +1543,8 @@
            photoList.add(new GameMemoryPhotoVO(tSubject.getId(), tSubject.getImg()));
            voiceList.add(new GameMemoryVoiceVO(tSubject.getId(), tSubject.getCorrect()));
        }
        // 校验超级听力是否通过
        // studyService.checkClearance(game,userStudy.getUserid());
        // 框架记忆数量翻倍，前端需要根据数量画格子
        game.setAnswerCount(game.getAnswerCount() * 2);
        return R.ok(new StudyGameMemoryVO(game, photoList, voiceList));
@@ -1329,30 +1620,47 @@
         * 例如:游戏配置的积分是100,他的正确率是50%那么拿50分,下次他再玩这个游戏 正确率是60% 那么他该获得60分 但是上次已经拿了50 所以这次就只给他加10积分
         */
        Integer userid = loginUserStudy.getUserid();
        TGame game = gameService.lambdaQuery().eq(TGame::getId, completeStudy.getGameId()).eq(TGame::getDisabled, 0).one();
        TGame game = gameService.lambdaQuery().eq(TGame::getId, completeStudy.getGameId())
                .eq(TGame::getDisabled, 0).one();
        if (null == game) {
            throw new GlobalException("游戏信息异常！");
        }
        // 积分明细
        List<TIntegralRecord> integralRecordList = integralRecordService.lambdaQuery().eq(TIntegralRecord::getUserId, userid)
                .eq(TIntegralRecord::getGameId, game.getId()).eq(TIntegralRecord::getDisabled, 0).list();
        Integer difficulty = completeStudy.getDifficulty();
        List<TIntegralRecord> integralRecordList = integralRecordService.lambdaQuery()
                .eq(TIntegralRecord::getUserId, userid)
                .eq(TIntegralRecord::getGameId, game.getId())
                .eq(TIntegralRecord::getDisabled, 0)
                .eq(TIntegralRecord::getGameDifficulty, difficulty).list();
        // 本次游戏总共能获取的积分数量
        Integer integral;
        Integer item = null;
        if (completeStudy.getGameName().equals(Constants.HEARING)) {
            // 本次游戏总积分
            integral = Integer.parseInt(game.getIntegral().split(",")[completeStudy.getDifficulty()]);
            integral = Integer.parseInt(game.getIntegral().split(",")[difficulty]);
            item = completeStudy.getDifficulty();
        } else if (completeStudy.getGameName().equals(Constants.MEMORY)) {
            integralRecordList = integralRecordService.lambdaQuery()
                    .eq(TIntegralRecord::getUserId, userid)
                    .eq(TIntegralRecord::getGameId, game.getId())
                    .eq(TIntegralRecord::getDisabled, 0)
                    .last("and gameDifficulty is null").list();
            integral = game.getAnswerIntegral();
        } else {
            throw new GlobalException("该次游戏积分计算异常！");
        }
        Integer accuracy = completeStudy.getAccuracy();
        if (accuracy >= 100) {
            accuracy = 100;
        }
        int gameAvailableIntegral = (int) (integral * ((double) completeStudy.getAccuracy() / 100));
        Integer availableIntegral = gameService.countIntegral(userid, game, completeStudy, gameAvailableIntegral, integralRecordList);
        // 游戏测试记录
        Boolean add = gameRecordService.add(completeStudy);
        // 可获得积分不为null时，才添加积分明细记录
        if (null != availableIntegral) {
            add = add && integralRecordService.add(String.valueOf(availableIntegral), Constants.COMPLETE_GAME, completeStudy.getGameId(), null);
        if (null != availableIntegral && !Constants.ZERO.equals(availableIntegral)) {
            add = add && integralRecordService.add(String.valueOf(availableIntegral),
                    Constants.COMPLETE_GAME, completeStudy.getGameId(), null, item, null);
            // 用户账户添加积分
            TUser user = userService.getById(userid);
            user.setIntegral(user.getIntegral() + availableIntegral);
@@ -1370,22 +1678,20 @@
        userStudy.setWeekStudy(userStudy.getWeekStudy() + completeStudy.getUseTime());
        userStudy.setMonthStudy(userStudy.getMonthStudy() + completeStudy.getUseTime());
        userStudyService.updateById(userStudy);
        // 学习配置列表
        List<TStudy> studyList = studyService.lambdaQuery().eq(TStudy::getDisabled, 0)
                .orderByAsc(TStudy::getWeek).list();
        if (studyList.isEmpty()) {
            throw new GlobalException("学习配置列表未配置或数据失效！");
        }
        // 超级记忆逻辑
        if (Constants.MEMORY.equals(completeStudy.getGameName())) {
            // 学习配置列表
            List<TStudy> studyList = studyService.lambdaQuery().eq(TStudy::getDisabled, 0)
                    .orderByAsc(TStudy::getWeek).list();
            if (studyList.isEmpty()) {
                throw new GlobalException("学习配置列表未配置或数据失效！");
            }
            // 超级记忆正确率达到通关率标准，才能进入下一周目学习
            // 校验是否通关超级听力与超级记忆，通关则学习记录更新为下一周目
            userStudyService.checkRate(game, userid, completeStudy, studyList);
            add = add && completeStudy.getAccuracy() >= Integer.parseInt(game.getAnswerRate());
        } else {
            // 超级听力需根据正确率判断是否允许进入下一难度
            userStudyService.gameHearing(game, userid, completeStudy);
            String rate = game.getRate().split(",")[completeStudy.getDifficulty()];
            add = add && completeStudy.getAccuracy() >= Integer.parseInt(rate);
            userStudyService.gameHearing(game, userid, completeStudy, studyList);
        }
        return R.ok(availableIntegral);
    }
@@ -1513,15 +1819,17 @@
        Integer userId = loginUserStudy.getUserid();
        Boolean result = true;
        // 学习时长更新
        TStudy study = studyService.lambdaQuery().eq(TStudy::getId, storyListen.getStudyId())
                .eq(TStudy::getDisabled, 0).one();
        TUserStudy userStudy = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, userId)
                .eq(TUserStudy::getDisabled, 0).one();
        if (null == userStudy) {
            userStudy = createUserStudy(userId);
            userStudy.setTotalStudy(userStudy.getTotalStudy() + studyTime);
            userStudy.setTodayStudy(userStudy.getTodayStudy() + studyTime);
            userStudy.setWeekStudy(userStudy.getWeekStudy() + studyTime);
            userStudy.setMonthStudy(userStudy.getMonthStudy() + studyTime);
        }
        userStudy.setTotalStudy(userStudy.getTotalStudy() + studyTime);
        userStudy.setTodayStudy(userStudy.getTodayStudy() + studyTime);
        userStudy.setWeekStudy(userStudy.getWeekStudy() + studyTime);
        userStudy.setMonthStudy(userStudy.getMonthStudy() + studyTime);
        boolean update = userStudyService.updateById(userStudy);
        if (!update) {
            throw new GlobalException("学习时长更新失败！");
@@ -1532,12 +1840,19 @@
            if (null == accuracy) {
                throw new GlobalException("自主故事-看图配音正确率异常！");
            }
            if (accuracy >= 100) {
                accuracy = 100;
            }
            // 看图配音模式，也需要根据游戏正确率计算积分
            int integral = storyListen.getLookIntegral() * (accuracy / 100);
            double d = (double) accuracy / 100;
            int integral = (int) (storyListen.getLookIntegral() * d);
            int obtainedIntegral;
            // 看图配音已获取积分数量
            List<TUserStudyRecord> list = studyRecordService.lambdaQuery()
                    .eq(TUserStudyRecord::getStoryId, storyId)
                    .eq(TUserStudyRecord::getType, 1)
                    .eq(TUserStudyRecord::getQuarter, study.getQuarter())
                    .eq(TUserStudyRecord::getWeek, storyListen.getWeek())
                    .eq(TUserStudyRecord::getUserId, userId).list();
            if (list.isEmpty()) {
                obtainedIntegral = 0;
@@ -1546,25 +1861,37 @@
                        .mapToInt(Integer::intValue).sum();
            }
            // 可获得积分计算
            if (integral > obtainedIntegral) {
            int i = integral - obtainedIntegral;
            if (i > 0) {
                TUserStudyRecord data = new TUserStudyRecord();
                data.setUserId(userId);
                data.setObtainedIntegral(integral - obtainedIntegral);
                data.setObtainedIntegral(i);
                data.setType(Constants.ONE);
                data.setStoryId(storyId);
                data.setQuarter(study.getQuarter());
                data.setWeek(storyListen.getWeek());
                result = studyRecordService.save(data);
                sum = integral - obtainedIntegral;
                sum = i;
                // 添加积分明细记录
                result = integralRecordService.add(String.valueOf(sum),
                        Constants.COMPLETE_STORY, null, storyId, null, Constants.ZERO);
                TUser user = userService.lambdaQuery().eq(TUser::getId, userId).one();
                // 添加积分
                user.setIntegral(user.getIntegral() + sum);
                result = result && userService.updateById(user);
            }
        } else {
            // 超级记忆只有首次才能获取积分
            TIntegralRecord integralRecord = integralRecordService.lambdaQuery()
                    .eq(TIntegralRecord::getUserId, userId)
                    .eq(TIntegralRecord::getStoryId, storyId)
                    .eq(TIntegralRecord::getDisabled, 0).one();
                    .eq(TIntegralRecord::getDisabled, 0)
                    .eq(TIntegralRecord::getStoryType, Constants.ONE)
                    .one();
            if (null == integralRecord) {
                // 添加积分明细记录
                result = integralRecordService.add(String.valueOf(storyListen.getIntegral()),
                        Constants.COMPLETE_STORY, null, storyId);
                        Constants.COMPLETE_STORY, null, storyId, null, Constants.ONE);
                TUser user = userService.lambdaQuery().eq(TUser::getId, userId).one();
                // 添加积分
                user.setIntegral(user.getIntegral() + storyListen.getIntegral());
@@ -1587,8 +1914,12 @@
        TUserStudy studyRecord = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, userId)
                .eq(TUserStudy::getDisabled, 0).one();
        // 总时长还需计算上游戏测试成绩时长
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery().eq(TGameRecord::getUserId, userId)
                .eq(TGameRecord::getDisabled, 0).list();
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery()
                .eq(TGameRecord::getUserId, userId)
                .eq(TGameRecord::getDisabled, 0)
                .orderByDesc(TGameRecord::getCreateTime)
                .list();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm");
        if (null != studyRecord) {
            // 学习时长格式转换
            Integer todayStudy = studyRecord.getTodayStudy();
@@ -1600,7 +1931,10 @@
            // 游戏总时长
            int sum = gameRecordList.stream().map(TGameRecord::getUseTime).mapToInt(Integer::intValue).sum();
            Integer totalStudy = studyRecord.getTotalStudy();
            studyRecord.setTotalStudy(Math.round((float) (totalStudy + sum) / 3600));
            studyRecord.setTotalStudy(Math.round((float) (totalStudy) / 3600));
            for (TGameRecord tGameRecord : gameRecordList) {
                tGameRecord.setTime(simpleDateFormat.format(tGameRecord.getCreateTime()));
            }
            // 剩余周目
            List<TStudy> studyList = studyService.lambdaQuery().eq(TStudy::getDisabled, 0)
                    .eq(TStudy::getType, Constants.ONE)
@@ -1623,6 +1957,44 @@

        // 学习记录
        TUserStudy studyRecord = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, userId)
                .eq(TUserStudy::getDisabled, 0).one();
        // 总时长还需计算上游戏测试成绩时长
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery()
                .eq(TGameRecord::getUserId, userId)
                .eq(TGameRecord::getDisabled, 0)
                .orderByDesc(TGameRecord::getCreateTime)
                .list();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm");
        if (null != studyRecord) {
            // 学习时长格式转换
            Integer todayStudy = studyRecord.getTodayStudy();
            studyRecord.setTodayStudy(Math.round((float) todayStudy / 3600));
            Integer weekStudy = studyRecord.getWeekStudy();
            studyRecord.setWeekStudy(Math.round((float) weekStudy / 3600));
            Integer monthStudy = studyRecord.getMonthStudy();
            studyRecord.setMonthStudy(Math.round((float) monthStudy / 3600));
            // 游戏总时长
            int sum = gameRecordList.stream().map(TGameRecord::getUseTime).mapToInt(Integer::intValue).sum();
            for (TGameRecord tGameRecord : gameRecordList) {
                tGameRecord.setTime(simpleDateFormat.format(tGameRecord.getCreateTime()));
            }
            Integer totalStudy = studyRecord.getTotalStudy();
            studyRecord.setTotalStudy(Math.round((float) (totalStudy) / 3600));
            // 剩余周目
            List<TStudy> studyList = studyService.lambdaQuery().eq(TStudy::getDisabled, 0)
                    .eq(TStudy::getType, Constants.ONE)
                    .orderByAsc(TStudy::getWeek).list();
            int size = studyService.residueWeek(studyRecord, studyList);
            studyRecord.setSurplus(size);
        }
        return R.ok(new StudyRecordResultVO(studyRecord, gameRecordList));
    }

    @PostMapping("/recordManagement/{id}")
    @ApiOperation(value = "游戏测试成绩", tags = {"管理后台-查看用户详情"})
    public R<StudyRecordResultVO> recordManagement(@PathVariable("id") Integer id) {
        // 学习记录
        TUserStudy studyRecord = userStudyService.lambdaQuery().eq(TUserStudy::getUserId, id)
                .eq(TUserStudy::getDisabled, 0).one();
        // 查询剩余周目
        if (studyRecord != null) {
@@ -1647,17 +2019,21 @@
        Integer monthStudy = studyRecord.getMonthStudy();
        studyRecord.setMonthStudy(Math.round((float) monthStudy / 3600));
        // 总时长还需计算上游戏测试成绩时长
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery().eq(TGameRecord::getUserId, userId)
        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery().eq(TGameRecord::getUserId, id)
                .eq(TGameRecord::getDisabled, 0).list();
        int sum = gameRecordList.stream().map(TGameRecord::getUseTime).mapToInt(Integer::intValue).sum();
        Integer totalStudy = studyRecord.getTotalStudy();
        studyRecord.setTotalStudy(Math.round((float) (totalStudy + sum) / 3600));
        return R.ok(new StudyRecordResultVO(studyRecord, gameRecordList));
        studyRecord.setTotalStudy(Math.round((float) (totalStudy) / 3600));
        StudyRecordResultVO studyRecordResultVO = new StudyRecordResultVO(studyRecord, gameRecordList);
        return R.ok(studyRecordResultVO);
    }

    @GetMapping("/getIntegral")
    @ApiOperation(value = "获取剩余积分", tags = {"家长端-获取剩余积分"})
    public R<Integer> getIntegral() {
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        Integer userId = tokenService.getLoginUser1().getUserid();
        return R.ok(userService.getById(userId).getIntegral());
    }
@@ -1702,12 +2078,17 @@
    public R<IPage<TIntegralRecord>> integralDetailParent(String time,
                                                          @RequestParam("pageNum") Integer pageNum,
                                                          @RequestParam("pageSize") Integer pageSize) {
        System.err.println("页码" + pageNum);
        System.err.println("页数" + pageSize);
        if (tokenService.getLoginUser1() == null) {
            return R.tokenError("登录失效");
        }
        return R.ok(integralRecordService.integralDetail(new Page<>(pageNum, pageSize), tokenService.getLoginUser1().getUserid(), time));
        IPage<TIntegralRecord> page = integralRecordService.integralDetail(new Page<>(pageNum, pageSize),
                tokenService.getLoginUser1().getUserid(), time);
        for (TIntegralRecord record : page.getRecords()) {
            if (!record.getIntegral().startsWith("-")) {
                record.setIntegral("+" + record.getIntegral());
            }
        }
        return R.ok(page);
    }

    /**