fix: 学习端bug

hjl

2024-07-01 355038c6e60a7648091eb84564918ac2dafde116

fix: 学习端bug

 ruoyi-service/ruoyi-goods/src/main/java/com/ruoyi/goods/service/impl/TGoodsServiceImpl.java

@@ -108,20 +108,28 @@
            // 检查库存总数是否足够
            List<TOrder> order = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
                    .eq(TOrder::getDisabled, 0).list();
            int item;
            if (!order.isEmpty()) {
                int totalNumber = order.stream().map(TOrder::getCount).collect(Collectors.toList())
                item = order.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
                boolean canBuy = good.getTotal() - totalNumber >= number;
                if (!canBuy) {
                    throw new GlobalException("商品库存不足，兑换失败！");
                }
            } else {
                item = 0;
            }
            boolean canBuy = good.getTotal() - item >= number;
            if (!canBuy) {
                throw new GlobalException("商品库存不足，兑换失败！");
            }
            // 检查用户兑换数量是否超过单用户最大兑换数量
            List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                    .eq(TOrder::getGoodsId, goodId).list();
            // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
            int totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                    .stream().mapToInt(Integer::intValue).sum();
            int totalNumber;
            if (orderList.isEmpty()) {
                totalNumber = 0;
            } else {
                // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            }
            boolean canExchange = orderList.isEmpty() || null == good.getUserCount() ||
                    (totalNumber + number) <= good.getUserCount();
            if (!canExchange) {
@@ -146,6 +154,27 @@
                return R.exchangeError("商品兑换失败！");
            }
        } else {
            if (null != good.getUserCount()) {
                // 检查用户兑换数量是否超过单用户最大兑换数量
                List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                        .eq(TOrder::getGoodsId, goodId).list();
                int totalNumber;
                if (orderList.isEmpty()) {
                    totalNumber = 0;
                } else {
                    // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                    totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                            .stream().mapToInt(Integer::intValue).sum();
                }
                Integer userCount = good.getUserCount();
                if (good.getUserCount() > totalNumber) {
                    int i = userCount - totalNumber;
                    if (number > i) {
                        return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
                                i + "！");
                    }
                }
            }
            boolean result = exchangeGood(goodExchange, recipient, number, goodId, needIntegral);
            if (!result) {
                return R.exchangeError("商品兑换失败！");
@@ -205,12 +234,31 @@
            return R.exchangeError("兑换失败，当前剩余积分不足！");
        }
        if (null != good.getTotal()) {
            // 检查库存总数是否足够
            List<TOrder> order = orderService.lambdaQuery().eq(TOrder::getGoodsId, goodId)
                    .eq(TOrder::getDisabled, 0).list();
            int item;
            if (!order.isEmpty()) {
                item = order.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            } else {
                item = 0;
            }
            boolean canBuy = good.getTotal() - item >= number;
            if (!canBuy) {
                throw new GlobalException("商品库存不足，兑换失败！");
            }
            // 检查用户兑换数量是否超过单用户最大兑换数量
            List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                    .eq(TOrder::getGoodsId, goodId).list();
            // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
            int totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                    .stream().mapToInt(Integer::intValue).sum();
            int totalNumber;
            if (orderList.isEmpty()) {
                totalNumber = 0;
            } else {
                // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                        .stream().mapToInt(Integer::intValue).sum();
            }
            boolean canExchange = orderList.isEmpty() || null == good.getUserCount() ||
                    (totalNumber + number) <= good.getUserCount();
            if (!canExchange) {
@@ -238,6 +286,27 @@
                return R.exchangeError("商品兑换失败！");
            }
        } else {
            if (null != good.getUserCount()) {
                // 检查用户兑换数量是否超过单用户最大兑换数量
                List<TOrder> orderList = orderService.lambdaQuery().eq(TOrder::getUserId, user.getId())
                        .eq(TOrder::getGoodsId, goodId).list();
                int totalNumber;
                if (orderList.isEmpty()) {
                    totalNumber = 0;
                } else {
                    // 该商品订单为空、订单数量未超过商品的单个用户兑换上限数量时，可以进行兑换
                    totalNumber = orderList.stream().map(TOrder::getCount).collect(Collectors.toList())
                            .stream().mapToInt(Integer::intValue).sum();
                }
                Integer userCount = good.getUserCount();
                if (good.getUserCount() > totalNumber) {
                    int i = userCount - totalNumber;
                    if (number > i) {
                        return R.exchangeError("兑换失败，当前兑换数量已超过最大兑换数量，剩余兑换数量为: " +
                                i + "！");
                    }
                }
            }
            boolean result = exchangeGoodParent(goodExchange, recipient, number, goodId, needIntegral);
            if (!result) {
                return R.exchangeError("商品兑换失败！");

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

@@ -738,6 +738,7 @@
            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);
        }
        return R.ok(studyRecord);
    }
@@ -962,6 +963,31 @@
    }

    /**
     * 退出游戏/故事学习
     */
    @GetMapping("/exitGameOrStory")
    @ApiOperation(value = "退出游戏/故事学习", tags = {"学习端-题目"})
    public R<Boolean> exitGameOrStory(@RequestParam 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));
    }

    /**
     * 自主学习1-听音选图
     *
     * @param week 周目

 ruoyi-service/ruoyi-study/src/main/java/com/ruoyi/study/domain/TIntegralRecord.java

@@ -1,9 +1,6 @@
package com.ruoyi.study.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.ruoyi.common.core.web.domain.BaseModel;
import io.swagger.annotations.ApiModelProperty;
@@ -70,11 +67,13 @@
    @ApiModelProperty("故事类型(0:看图配音；1:框架记忆)")
    private Integer storyType;

    @ApiModelProperty("积分变动时间")
    @TableField(exist = false)
    /**
     * 创建时间
     */
    @ApiModelProperty(value = "积分变动时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm")
    private Date time;

    @TableField(value = "createTime", fill = FieldFill.INSERT)
    private Date createTime;


    /**

 ruoyi-service/ruoyi-study/src/main/java/com/ruoyi/study/service/ITStudyService.java

@@ -30,10 +30,11 @@
    /**
     * 获取学习进度及学习时长等信息
     *
     * @param userId 用户id
     * @param studyRecord 学习进度
     * @param week        所属周目
     * @return 学习信息
     */
    TUserStudy studySchedule(String userId);
    TUserStudy studySchedule(TUserStudy studyRecord, Integer week);

    /**
     * 自主学习1-听音选图

 ruoyi-service/ruoyi-study/src/main/java/com/ruoyi/study/service/ITUserStudyService.java

@@ -20,14 +20,6 @@
public interface ITUserStudyService extends IService<TUserStudy> {

    /**
     * 获取学习进度及学习时长等信息
     *
     * @param userId 用户id
     * @return 学习信息
     */
    TUserStudy studySchedule(String userId);

    /**
     * 定时任务 清空用户学习时长
     *
     * @param time 今日/本周/本月

 ruoyi-service/ruoyi-study/src/main/java/com/ruoyi/study/service/impl/TStudyServiceImpl.java

@@ -67,7 +67,9 @@
            int total = 0;
            List<Integer> dayList = new ArrayList<>();
            // 有问有答
            List<TStudyAnswer> answerList = studyAnswerService.lambdaQuery().eq(TStudyAnswer::getStudyId, id)
            List<TStudyAnswer> answerList = studyAnswerService.lambdaQuery()
                    .eq(TStudyAnswer::getStudyId, id)
                    .eq(TStudyAnswer::getWeek, week)
                    .eq(TStudyAnswer::getDisabled, 0).list();
            for (TStudyAnswer data : answerList) {
                Integer day = data.getDay();
@@ -78,7 +80,9 @@
            }
            dayList.clear();
            // 归纳判断
            List<TStudyInduction> inductionList = studyInductionService.lambdaQuery().eq(TStudyInduction::getStudyId, id)
            List<TStudyInduction> inductionList = studyInductionService.lambdaQuery()
                    .eq(TStudyInduction::getStudyId, id)
                    .eq(TStudyInduction::getWeek, week)
                    .eq(TStudyInduction::getDisabled, 0).list();
            for (TStudyInduction data : inductionList) {
                Integer day = data.getDay();
@@ -89,7 +93,9 @@
            }
            dayList.clear();
            // 看图选音
            List<TStudyLook> lookList = studyLookService.lambdaQuery().eq(TStudyLook::getStudyId, id)
            List<TStudyLook> lookList = studyLookService.lambdaQuery()
                    .eq(TStudyLook::getStudyId, id)
                    .eq(TStudyLook::getWeek, week)
                    .eq(TStudyLook::getDisabled, 0).list();
            for (TStudyLook data : lookList) {
                Integer day = data.getDay();
@@ -100,7 +106,9 @@
            }
            dayList.clear();
            // 听音选图
            List<TStudyListen> listenList = studyListenService.lambdaQuery().eq(TStudyListen::getStudyId, id)
            List<TStudyListen> listenList = studyListenService.lambdaQuery()
                    .eq(TStudyListen::getStudyId, id)
                    .eq(TStudyListen::getWeek, week)
                    .eq(TStudyListen::getDisabled, 0).list();
            for (TStudyListen data : listenList) {
                Integer day = data.getDay();
@@ -111,7 +119,9 @@
            }
            dayList.clear();
            // 音图相配
            List<TStudyPair> pairList = studyPairService.lambdaQuery().eq(TStudyPair::getStudyId, id)
            List<TStudyPair> pairList = studyPairService.lambdaQuery()
                    .eq(TStudyPair::getStudyId, id)
                    .eq(TStudyPair::getWeek, week)
                    .eq(TStudyPair::getDisabled, 0).list();
            for (TStudyPair data : pairList) {
                Integer day = data.getDay();
@@ -123,7 +133,8 @@
            dayList.clear();
            // 自主游戏
            List<TGame> gameList = gameService.lambdaQuery().eq(TGame::getStudyId, id)
                    .eq(TGame::getDisabled, 0).list();
                    .eq(TGame::getDisabled, 0)
                    .eq(TGame::getWeek, week).list();
            // 自主游戏-超级听力
            List<String> gameIntegral = gameList.stream().map(TGame::getIntegral).collect(Collectors.toList());
            for (String s : gameIntegral) {
@@ -138,7 +149,9 @@
                }
            }
            // 自主故事
            List<TStoryListen> storyListenList = storyListenService.lambdaQuery().eq(TStoryListen::getStudyId, id)
            List<TStoryListen> storyListenList = storyListenService.lambdaQuery()
                    .eq(TStoryListen::getStudyId, id)
                    .eq(TStoryListen::getWeek, week)
                    .eq(TStoryListen::getDisabled, 0).list();
            // 自主故事 - 框架记忆
            total += storyListenList.stream().map(TStoryListen::getIntegral).mapToInt(Integer::intValue).sum();
@@ -149,6 +162,88 @@
            result.add(new StudyWeekDTO(week, type, quarter, title, total, canStudy));
        }
        return result;
    }

    @Override
    public TUserStudy studySchedule(TUserStudy studyRecord, Integer week) {
        // 剩余周目
        List<TStudy> studyList = this.lambdaQuery().eq(TStudy::getDisabled, 0)
                .eq(TStudy::getType, Constants.ONE)
                .orderByAsc(TStudy::getWeek).list();
        // 已学习到的周目
        Integer studyWeek = studyRecord.getWeek();
        // 学习到的季度
        Integer studyQuarter = 1;
        // 当前所点击进入的周目所属季度
        Integer currentQuarter = 1;
        // 根据季度分组封装
        Map<Integer, List<TStudy>> integerListMap = getIntegerListMap(studyList);
        for (Map.Entry<Integer, List<TStudy>> map : integerListMap.entrySet()) {
            List<TStudy> list = map.getValue();
            for (TStudy study : list) {
                Integer itemWeek = study.getWeek();
                if (studyWeek.equals(itemWeek)) {
                    studyQuarter = map.getKey();
                    break;
                }
            }
            for (TStudy study : list) {
                Integer itemWeek = study.getWeek();
                if (week.equals(itemWeek)) {
                    currentQuarter = map.getKey();
                    break;
                }
            }
        }
        // 已学习季度 大于当前周目所属季度，所有学习均已完成
        if (studyQuarter > currentQuarter) {
            studyRecord.setWeek(week);
            studyRecord.setDay(Constants.SIX);
            studyRecord.setListen(Constants.ONE_HUNDRED);
            studyRecord.setLook(Constants.ONE_HUNDRED);
            studyRecord.setInduction(Constants.ONE_HUNDRED);
            studyRecord.setAnswer(Constants.ONE_HUNDRED);
            studyRecord.setPair(Constants.ONE_HUNDRED);
            studyRecord.setGameDifficulty(Constants.TWO);
            studyRecord.setComputeSchedule(Constants.ONE_HUNDRED);
        } else if (studyQuarter < currentQuarter) {
            studyRecord.setWeek(week);
            studyRecord.setDay(Constants.ONE);
            studyRecord.setListen(Constants.BURDEN_ONE);
            studyRecord.setLook(Constants.BURDEN_ONE);
            studyRecord.setInduction(Constants.BURDEN_ONE);
            studyRecord.setAnswer(Constants.BURDEN_ONE);
            studyRecord.setPair(Constants.BURDEN_ONE);
            studyRecord.setGameDifficulty(null);
            studyRecord.setComputeSchedule(Constants.ZERO);
        } else {
            List<TStudy> tStudies = integerListMap.get(studyQuarter);
            List<Integer> weekList = tStudies.stream().map(TStudy::getWeek).collect(Collectors.toList());
            int i = weekList.indexOf(studyWeek);
            int i1 = weekList.indexOf(week);
            if (i > i1) {
                studyRecord.setWeek(week);
                studyRecord.setDay(Constants.SIX);
                studyRecord.setListen(Constants.ONE_HUNDRED);
                studyRecord.setLook(Constants.ONE_HUNDRED);
                studyRecord.setInduction(Constants.ONE_HUNDRED);
                studyRecord.setAnswer(Constants.ONE_HUNDRED);
                studyRecord.setPair(Constants.ONE_HUNDRED);
                studyRecord.setGameDifficulty(Constants.TWO);
                studyRecord.setComputeSchedule(Constants.ONE_HUNDRED);
            } else if (i < i1) {
                studyRecord.setWeek(week);
                studyRecord.setDay(Constants.ONE);
                studyRecord.setListen(Constants.BURDEN_ONE);
                studyRecord.setLook(Constants.BURDEN_ONE);
                studyRecord.setInduction(Constants.BURDEN_ONE);
                studyRecord.setAnswer(Constants.BURDEN_ONE);
                studyRecord.setPair(Constants.BURDEN_ONE);
                studyRecord.setGameDifficulty(null);
                studyRecord.setComputeSchedule(Constants.ZERO);
            }
        }
        return studyRecord;
    }

    /**
@@ -179,11 +274,6 @@
        }
        // 学习记录所属周目大于当前学习周目，判断为已学习
        return userStudy.getWeek() >= study.getWeek();
    }

    @Override
    public TUserStudy studySchedule(String userId) {
        return userStudyService.studySchedule(userId);
    }

    @Override
@@ -453,8 +543,6 @@
            itemList.add(study);
            studyMap.put(quarter, itemList);
        }
        // 临时判断参数
        boolean itemBool = false;
        // 学习进度所属季度
        int studyQuarter = 1;
        // 当前进入周目所属季度
@@ -618,6 +706,71 @@
        // 已学习到的周目
        Integer studyWeek = studyRecord.getWeek();
        // 根据季度分组封装
        Map<Integer, List<TStudy>> itemMap = getIntegerListMap(studyList);
        // 计算已学习周目
        boolean v = false;
        for (Map.Entry<Integer, List<TStudy>> map : itemMap.entrySet()) {
            List<TStudy> list = map.getValue();
            for (int i = 0; i < list.size(); i++) {
                TStudy item = list.get(i);
                if (item.getWeek().equals(studyWeek)) {
                    Integer listen = studyRecord.getListen();
                    Integer answer = studyRecord.getAnswer();
                    Integer look = studyRecord.getLook();
                    Integer induction = studyRecord.getInduction();
                    Integer pair = studyRecord.getPair();
                    Integer gameDifficulty = studyRecord.getGameDifficulty();
                    // 听音选图、看图选音、音图相配、有问有答、归纳排除的进度是否 100%，并且超级听力的游戏难度是否为2
                    boolean isStudy = Constants.ONE_HUNDRED.equals(listen) && Constants.ONE_HUNDRED.equals(look) &&
                            Constants.ONE_HUNDRED.equals(induction) && Constants.ONE_HUNDRED.equals(pair) &&
                            Constants.ONE_HUNDRED.equals(answer) && Constants.TWO.equals(gameDifficulty);
                    // 并且超级听力难度2已通过
                    TStudy study = this.lambdaQuery().eq(TStudy::getWeek, studyRecord.getWeek())
                            .eq(TStudy::getDisabled, 0)
                            .one();
                    TGame game = gameService.lambdaQuery()
                            .eq(TGame::getStudyId, study.getId())
                            .eq(TGame::getDisabled, 0)
                            .eq(TGame::getWeek, study.getWeek())
                            .one();
                    if (null != game) {
                        String rate = game.getRate().split(",")[2];
                        List<TGameRecord> gameRecordList = gameRecordService.lambdaQuery()
                                .eq(TGameRecord::getGameDifficulty, Constants.TWO)
                                .ge(TGameRecord::getAccuracy, rate)
                                .eq(TGameRecord::getUserId, studyRecord.getUserId())
                                .eq(TGameRecord::getGameId, game.getId())
                                .list();
                        if (gameRecordList.isEmpty()) {
                            isStudy = false;
                        }
                        List<TGameRecord> recordList = gameRecordService.lambdaQuery()
                                .ge(TGameRecord::getAccuracy, game.getAnswerRate())
                                .eq(TGameRecord::getUserId, studyRecord.getUserId())
                                .eq(TGameRecord::getGameId, game.getId())
                                .last("and gameDifficulty is null")
                                .list();
                        if (recordList.isEmpty()) {
                            isStudy = false;
                        }
                    }
                    if (isStudy) {
                        residueWeek++;
                    }
                    v = true;
                    break;
                } else {
                    residueWeek++;
                }
            }
            if (v) {
                break;
            }
        }
        return studyList.size() - residueWeek;
    }

    private Map<Integer, List<TStudy>> getIntegerListMap(List<TStudy> studyList) {
        Map<Integer, List<TStudy>> studyMap = new HashMap<>(8);
        for (TStudy study : studyList) {
            Integer quarter = study.getQuarter();
@@ -640,37 +793,7 @@
            List<TStudy> itemList = studyMap.get(key);
            itemMap.put(key, itemList);
        }
        // 计算已学习周目
        boolean v = false;
        for (Map.Entry<Integer, List<TStudy>> map : itemMap.entrySet()) {
            List<TStudy> list = map.getValue();
            for (int i = 0; i < list.size(); i++) {
                TStudy item = list.get(i);
                if (item.getWeek().equals(studyWeek)) {
                    Integer listen = studyRecord.getListen();
                    Integer answer = studyRecord.getAnswer();
                    Integer look = studyRecord.getLook();
                    Integer induction = studyRecord.getInduction();
                    Integer pair = studyRecord.getPair();
                    Integer gameDifficulty = studyRecord.getGameDifficulty();
                    // 听音选图、看图选音、音图相配、有问有答、归纳排除的进度是否 100%，并且超级听力的游戏难度是否为2
                    boolean isStudy = Constants.ONE_HUNDRED.equals(listen) && Constants.ONE_HUNDRED.equals(look) &&
                            Constants.ONE_HUNDRED.equals(induction) && Constants.ONE_HUNDRED.equals(pair) &&
                            Constants.ONE_HUNDRED.equals(answer) && Constants.TWO.equals(gameDifficulty);
                    if (isStudy) {
                        residueWeek++;
                    }
                    v = true;
                    break;
                } else {
                    residueWeek++;
                }
            }
            if (v) {
                break;
            }
        }
        return studyList.size() - residueWeek;
        return itemMap;
    }

    @Override

 ruoyi-service/ruoyi-study/src/main/java/com/ruoyi/study/service/impl/TUserStudyServiceImpl.java

@@ -1,6 +1,5 @@
package com.ruoyi.study.service.impl;

import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.constant.Constants;
import com.ruoyi.study.domain.TGame;
@@ -56,12 +55,6 @@
        // 游戏难度
        GAME_DIFFICULTY_MAP.put(Constants.ZERO, Constants.ONE);
        GAME_DIFFICULTY_MAP.put(Constants.ONE, Constants.TWO);
    }

    @Override
    public TUserStudy studySchedule(String userId) {
        LambdaQueryChainWrapper<TUserStudy> wrapper = lambdaQuery().eq(TUserStudy::getUserId, userId);
        return wrapper.eq(TUserStudy::getDisabled, 0).one();
    }

    @Override