完善

hcp-app/src/main/java/com/yingyangfly/app/controller/VoiceController.java

@@ -39,7 +39,21 @@ public class VoiceController {
         if(!StringUtils.isEmpty(voiceUrl)){
              return ResultResponse.success(voiceUrl);
         }else{
-            return baiduVoiceUtil.getVoiceUrl(voiceMsg);
+            return baiduVoiceUtil.getVoiceUrl(voiceMsg,"5");
+        }
+    }
+
+
+    @Log(title = "游戏介绍语言合成",operatorType = OperatorType.MOBILE)
+    @ApiOperation("游戏介绍语言合成")
+    @RequestMapping("/game/getVoiceUrl")
+    @TraceLog
+    public ResultResponse getGameVoiceUrl(String voiceMsg){
+        String voiceUrl = redisClient.get("hcp:voice:"+MD5Util.md5(voiceMsg),"");
+        if(!StringUtils.isEmpty(voiceUrl)){
+            return ResultResponse.success(voiceUrl);
+        }else{
+            return baiduVoiceUtil.getVoiceUrl(voiceMsg,"3");
         }
     }
 }

hcp-app/src/main/java/com/yingyangfly/app/util/BaiduVoiceUtil.java

@@ -47,7 +47,7 @@ public class BaiduVoiceUtil {
     private RedisClient redisClient;
 
 
-    public ResultResponse getVoiceUrl(String voiceMsg){
+    public ResultResponse getVoiceUrl(String voiceMsg,String spd){
         if(client == null){
             // 初始化一个AipSpeech
             client = new AipSpeech(APP_ID, API_KEY, SECRET_KEY);
@@ -57,7 +57,7 @@ public class BaiduVoiceUtil {
         client.setSocketTimeoutInMillis(60000);
         // 调用接口
         HashMap<String, Object> options = new HashMap<String, Object>();
-        options.put("spd", "5");
+        options.put("spd", spd);
         options.put("pit", "5");
         options.put("per", "0");
         TtsResponse res = client.synthesis(voiceMsg, "zh", 1, options);

hcp-core/src/main/java/com/yingyangfly/core/api/impl/ImApiImpl.java

@@ -123,6 +123,11 @@ public class ImApiImpl implements ImApi {
         String jsonString = JSON.toJSONString(jsonObject);
         log.info("msg:{}",jsonString);
         HttpResponse response = HttpUtil.createPost(url).body(jsonString).execute();
+        JSONObject resp = JSON.parseObject(response.body());
+        Integer errorCode = resp.getInteger("ErrorCode");
+        if (errorCode != 0){
+            throw new RuntimeException("添加IM错误");
+        }
         log.info("response body:{}",response.body());
         return response.body();
     }

hcp-core/src/main/java/com/yingyangfly/core/domain/GamePlayRecord.java

@@ -52,4 +52,7 @@ public class GamePlayRecord {
 
     @Field("game_relevancy_id")
     private Long gameRelevancyId;
+
+    @Field("del_flag")
+    private Integer delFlag;
 }

hcp-core/src/main/java/com/yingyangfly/core/recommend/RecommendFacade.java

@@ -21,6 +21,7 @@ import com.yingyangfly.core.service.*;
 import com.yingyangfly.core.service.impl.AppUserService;
 import com.yingyangfly.core.service.impl.SysDictDataService;
 import com.yingyangfly.redis.client.RedisClient;
+import io.swagger.models.auth.In;
 import lombok.extern.slf4j.Slf4j;
 import org.jacoco.agent.rt.internal_035b120.core.internal.flow.IFrame;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -28,6 +29,9 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.support.TransactionSynchronizationManager;
 import javax.annotation.Resource;
+import java.lang.reflect.Array;
+import java.time.LocalDate;
+import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
@@ -73,16 +77,7 @@ public class RecommendFacade {
 
 
     @Resource
-    ReviewTaskService reviewTaskService;
-
-    @Resource
-    ReviewRecordMapper reviewRecordMapper;
-
-    @Resource
-    ReviewService reviewService;
-
-    @Resource
-    GameRecommendationRecordService gameRecommendationRecordService;
+    GameTaskDetailService gameTaskDetailService;
 
     /**
      * 给用户推荐 畅游蓝豚和 首页推荐
@@ -195,7 +190,7 @@ public class RecommendFacade {
         log.info("<<<<<<<<<<<<保存推荐游戏记录响应:{}>>>>>>>>>>>>>>",gameRecommend);
     }
     /**
-     * 推荐 蓝豚 或者 首页
+     * 推荐 首页
      *
      * @param rule
      * @throws InterruptedException
@@ -216,7 +211,7 @@ public class RecommendFacade {
                 String thName = Thread.currentThread().getName();
                 log.info("形成gameUser Thread: {}", thName);
                 for (AppUser appUser : appUsers) {
-                    List<Game> games = getGameAccordingByRules(rule, appUser);
+                    List<Game> games = recommendationB(appUser);
                     if (CollectionUtil.isEmpty(games)) {
                         continue;
                     }
@@ -233,6 +228,9 @@ public class RecommendFacade {
         log.info("<<<<<<<<<<<<保存推荐游戏记录>>>>>>>>>>>>>>");
         boolean gameRecommend = gameRecommendRecordService.saveBatch(allGameUsers, rule.getOrgCode(), rule.getOrgName(), rule.getRecommendPlayClass());
         log.info("<<<<<<<<<<<<保存推荐游戏记录响应:{}>>>>>>>>>>>>>>",gameRecommend);
+        log.info("<<<<<<<<<<<<<<<<删除已经通关数据开始>>>>>>>>>>>>>>>>>>");
+        gameUserService.removeDelUserGameDone();
+        log.info("<<<<<<<<<<<<<<<<删除已经通关数据结束>>>>>>>>>>>>>>>>>>");
     }
 
     private void recommendUserBorCByRule(GameRecommendRule rule, AppUser appUser) {
@@ -378,176 +376,313 @@ public class RecommendFacade {
      * @return
      */
     private List<Game> recommendationA(AppUser appUser){
-        // 以生成理疗任务的返回空
-        List<Game> gameList = Lists.newArrayList();
-
-        QueryWrapper<GameTask> gameTaskWrapper = new QueryWrapper();
-        gameTaskWrapper.eq("user_id", appUser.getId());
-        gameTaskWrapper.eq("task_start_time", DateUtil.today());
-        GameTask gameTasks = gameTaskService.getOne(gameTaskWrapper);
-        if (ObjectUtils.isNotNull(gameTasks)){
+        String tags = appUser.getTags();
+        if (ObjectUtils.isNull(tags)){
             return null;
         }
-        log.info("=======================今日理疗任务为空继续执行======================");
-        //  测评有问题的 类型
-        Set<String> typeSet = new HashSet<>();
-        // 查询用户最近测评任务
-        LambdaQueryWrapper<ReviewTask> mocaWrapper = new LambdaQueryWrapper<>();
-        mocaWrapper.eq(ReviewTask::getUserId,appUser.getId());
-        mocaWrapper.orderByDesc(ReviewTask::getReviewTime)
-                .last("limit 1");
-        mocaWrapper.eq(ReviewTask::getType,"MOCA");
-        mocaWrapper.eq(ReviewTask::getStatus,"1");
-        ReviewTask mocaReviewTask = reviewTaskService.getOne(mocaWrapper);
-
-        LambdaQueryWrapper<ReviewTask> mmseWrapper = new LambdaQueryWrapper<>();
-        mmseWrapper.eq(ReviewTask::getUserId,appUser.getId());
-        mmseWrapper.orderByDesc(ReviewTask::getReviewTime)
-                .last("limit 1");
-        mmseWrapper.eq(ReviewTask::getType,"MMSE");
-        mmseWrapper.eq(ReviewTask::getStatus,"1");
-        ReviewTask mmseReviewTask = reviewTaskService.getOne(mmseWrapper);
-
-        String reviewTaskId  = null;
-
-        if (ObjectUtils.isNotNull(mocaReviewTask)){
-            reviewTaskId = mocaReviewTask.getReviewTaskId();
-            LambdaQueryWrapper<ReviewRecord> mocaReviewRecordWrapper = new LambdaQueryWrapper<>();
-            mocaReviewRecordWrapper.eq(ReviewRecord::getUserId,appUser.getId());
-            mocaReviewRecordWrapper.eq(ReviewRecord::getReviewTaskId,mocaReviewTask.getId());
-            mocaReviewRecordWrapper.eq(ReviewRecord::getCorrect,"0");
-            List<ReviewRecord> mocaReviewRecords = reviewRecordMapper.selectList(mocaReviewRecordWrapper);
-            for (ReviewRecord mocaReviewRecord : mocaReviewRecords) {
-                Review mocaReview = reviewService.getById(mocaReviewRecord.getReviewId());
-                typeSet.add(mocaReview.getViewType());
+        List<Game> gameList = new ArrayList<>();
+        // 用户认知障碍 标签
+        List<String> tagLsis = Arrays.stream(tags.split(",")).collect(Collectors.toList());
+        // 获取游戏难度
+        String difficultyLevel = difficultyLevel(appUser);
+        // 获取游戏
+        for (String tag : tagLsis) {
+            LambdaQueryWrapper<Game> gameLambdaQueryWrapper = new LambdaQueryWrapper<>();
+            gameLambdaQueryWrapper.eq(Game::getGameType,tag);
+            gameLambdaQueryWrapper.eq(Game::getGameDifficulty,difficultyLevel);
+            List<Game> list = gameService.list(gameLambdaQueryWrapper);
+            // 大于等于4时去掉上次推荐的游戏
+            if (list.size() >= 4){
+                LambdaQueryWrapper<GameTask> gameTaskLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                gameTaskLambdaQueryWrapper.eq(GameTask::getUserId,appUser.getId());
+                gameTaskLambdaQueryWrapper.orderByDesc(GameTask::getTaskStartTime).last("limit 1");
+                GameTask gameTask = gameTaskService.getOne(gameTaskLambdaQueryWrapper);
+                if (gameTask != null){
+                    LambdaQueryWrapper<GameTaskDetail> gameTaskDetailLambdaQueryWrapper = new LambdaQueryWrapper<>();
+                    gameTaskDetailLambdaQueryWrapper.eq(GameTaskDetail::getTaskId,gameTask.getId());
+                    gameTaskDetailLambdaQueryWrapper.eq(GameTaskDetail::getGameType,tag);
+                    List<GameTaskDetail> gameTaskDetailList = gameTaskDetailService.list(gameTaskDetailLambdaQueryWrapper);
+                    if (!gameTaskDetailList.isEmpty() && gameTaskDetailList.size() <= 2){
+                        Set<String> gameCodesToDelete = gameTaskDetailList.stream()
+                                .map(GameTaskDetail::getGameCode)
+                                .collect(Collectors.toSet());
+                        List<Game> filteredGameList = list.stream()
+                                .filter(game -> !gameCodesToDelete.contains(game.getGameCode()))
+                                .collect(Collectors.toList());
+                        list.clear(); // 清空原始列表
+                        list.addAll(filteredGameList); // 将过滤后的列表添加到原始列表中
+                    }
+                }
             }
-        }
-
-        if (ObjectUtils.isNotNull(mmseReviewTask)){
-            reviewTaskId = mmseReviewTask.getReviewTaskId();
-            LambdaQueryWrapper<ReviewRecord> mocaReviewRecordWrapper = new LambdaQueryWrapper<>();
-            mocaReviewRecordWrapper.eq(ReviewRecord::getUserId,appUser.getId());
-            mocaReviewRecordWrapper.eq(ReviewRecord::getReviewTaskId,mmseReviewTask.getId());
-            mocaReviewRecordWrapper.eq(ReviewRecord::getCorrect,"0");
-            List<ReviewRecord> mmseReviewRecords = reviewRecordMapper.selectList(mocaReviewRecordWrapper);
-            for (ReviewRecord mmseReviewRecord : mmseReviewRecords) {
-                Review mocaReview = reviewService.getById(mmseReviewRecord.getReviewId());
-                typeSet.add(mocaReview.getViewType());
+            // 去除之后 小于等于2时 之间添加 否则随机获取两个
+            if (list.size() <= 2){
+                gameList.addAll(list);
+            }else {
+                // 打乱集合，获取前两个
+                Collections.shuffle(list);
+                gameList.add(list.get(0));
+                gameList.add(list.get(1));
             }
         }
-        if (ObjectUtils.isNull(reviewTaskId)){
+        return gameList;
+    }
+
+    /**
+     * 推荐 认知训练游戏
+     * @param appUser
+     * @return
+     */
+    private List<Game> recommendationB(AppUser appUser) {
+        String tags = appUser.getTags();
+        if (ObjectUtils.isNull(tags)){
             return null;
         }
+        List<Game> gameList = new ArrayList<>();
+        List<String> tagList = Arrays.stream(tags.split(",")).collect(Collectors.toList());
+        // 获取游戏难度
+        String difficultyLevel = difficultyLevel(appUser);
+
+        // 获取所以游戏 并按认知域进行划分
+        LambdaQueryWrapper<Game> gameLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        gameLambdaQueryWrapper.eq(Game::getGameDifficulty,difficultyLevel);
+        List<Game> games = gameService.list(gameLambdaQueryWrapper);
+        Map<String, List<Game>> typeToGameMap = games.stream().collect(Collectors.groupingBy(Game::getGameType));
+
+        //判断是否三天时间都没有通关游戏，如果是就删除以前的游戏，重新随机推荐
+        LambdaQueryWrapper<GameUser> wrapper = new LambdaQueryWrapper();
+        wrapper.eq(GameUser::getPlayClass, "B");
+        wrapper.eq(GameUser::getUserId,appUser.getId());
+        wrapper.eq(GameUser::getStatus,StatusEnums.OK.getCode());
+        wrapper.le(GameUser::getCreateTime, LocalDate.now().atStartOfDay());
+        LocalDate threeDaysAgo = LocalDate.now().minus(3, ChronoUnit.DAYS);
+        wrapper.ge(GameUser::getCreateTime, threeDaysAgo.atStartOfDay()); // 大于等于三天前的开始时间
+        long count = gameUserService.count(wrapper);
+        if (count==0){
+            LambdaQueryWrapper<GameUser> deleteWrapper = new LambdaQueryWrapper();
+            deleteWrapper.eq(GameUser::getPlayClass, "B");
+            deleteWrapper.eq(GameUser::getUserId,appUser.getId());
+            deleteWrapper.eq(GameUser::getStatus,StatusEnums.DISABLE.getCode());
+            gameUserService.remove(deleteWrapper);
+        }
 
-        Integer frequency = 1;
-        Integer recommendNum = 1;
-
-        // 获取这个评估任务以前推荐的游戏
-        LambdaQueryWrapper<GameRecommendationRecord> gameRecommendationRecordLambdaQueryWrapper = new LambdaQueryWrapper<>();
-        gameRecommendationRecordLambdaQueryWrapper.eq(GameRecommendationRecord::getReviewTaskId,reviewTaskId);
-        gameRecommendationRecordLambdaQueryWrapper.eq(GameRecommendationRecord::getPlayClass,"A");
-        gameRecommendationRecordLambdaQueryWrapper.orderByDesc(GameRecommendationRecord::getCreateTime)
-                .last("limit 1");
-        GameRecommendationRecord one = gameRecommendationRecordService.getOne(gameRecommendationRecordLambdaQueryWrapper);
-        if (ObjectUtils.isNotNull(one)){
-            // 不为空，判断是否推荐了7次
-            if (one.getRecommendNum() != 7) {
-                List<String> GameCodes = Arrays.stream(one.getGameCodes().split(","))
-                        .collect(Collectors.toList());
-                for (String gameCode : GameCodes) {
-                    LambdaQueryWrapper<Game> gameWrapper = new LambdaQueryWrapper<>();
-                    gameWrapper.eq(Game::getGameCode,gameCode).last("limit 1");
-                    Game game = gameService.getOne(gameWrapper);
-                    if (ObjectUtils.isNotNull(game)){
-                        gameList.add(game);
+        // 判断用户 认知障碍对应的认知域 是否有两个未通关的游戏，缺少了进行添加
+        // 获取未通过的 专属训练游戏(原 推荐游戏)
+        LambdaQueryWrapper<GameUser> gameUserLambdaQueryWrapper = new LambdaQueryWrapper<>();
+        gameUserLambdaQueryWrapper.eq(GameUser::getUserId,appUser.getId());
+        gameUserLambdaQueryWrapper.eq(GameUser::getStatus,StatusEnums.DISABLE.getCode());
+        gameUserLambdaQueryWrapper.eq(GameUser::getPlayClass,"B");
+        List<GameUser> gameUserList = gameUserService.list(gameUserLambdaQueryWrapper);
+        Map<String, List<GameUser>> typeToUsersMap = gameUserList.stream()
+                .collect(Collectors.groupingBy(GameUser::getGameType));
+        // 判断每个认知域 是否有两个未完成的游戏
+        for (String tag : tagList) {
+            List<GameUser> gameUsers = typeToUsersMap.getOrDefault(tag, Collections.emptyList());
+            LambdaQueryWrapper<GameUser> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+            lambdaQueryWrapper.eq(GameUser::getUserId,appUser.getId());
+            lambdaQueryWrapper.eq(GameUser::getStatus,StatusEnums.OK.getCode());
+            lambdaQueryWrapper.eq(GameUser::getPlayClass,"B");
+
+            List<Game> tagGameList = typeToGameMap.getOrDefault(tag, Collections.emptyList());
+            // 该认知域 游戏少于两个补全到两个
+            if (gameUsers.size() == 1) {
+                // 排除已经存在的
+                List<Game> tagGamesList1 = tagGameList.stream().filter(game -> !game.getGameCode().equals(gameUsers.get(0).getGameCode())).collect(Collectors.toList());
+
+                lambdaQueryWrapper.orderByDesc(GameUser::getUpdateTime).last("limit 1");
+                GameUser gameUser = gameUserService.getOne(lambdaQueryWrapper);
+                // 判读是否为空
+                if (ObjectUtils.isNull(gameUser)){
+                    // 为空直接随机获取
+                    if (!tagGamesList1.isEmpty()){
+                        if (tagGamesList1.size() > 1){
+                            Collections.shuffle(tagGamesList1);
+                        }
+                        gameList.add(tagGamesList1.get(0));
                     }
-                }
-                frequency = one.getFrequency();
-                recommendNum = one.getRecommendNum() + 1;
-            } else {
-                //  为空当作已经推荐了7次，排除已经推荐后的游戏再推荐
-                // 存在两种情况  一种 所有游戏已经全部推荐完了，再次随机推荐,  第二种情况  还有游戏没有推荐，排除已经推荐的，对没有推荐的游戏随机推荐
-
-                // 获取已推荐的所有游戏
-                LambdaQueryWrapper<GameRecommendationRecord> gameRecommendationRecordQueryWrapper = new LambdaQueryWrapper<>();
-                gameRecommendationRecordQueryWrapper.eq(GameRecommendationRecord::getReviewTaskId,reviewTaskId);
-                gameRecommendationRecordQueryWrapper.eq(GameRecommendationRecord::getFrequency,one.getFrequency());
-                gameRecommendationRecordQueryWrapper.eq(GameRecommendationRecord::getPlayClass,"A");
-                List<GameRecommendationRecord> gameRecommendationRecordList = gameRecommendationRecordService.list(gameRecommendationRecordLambdaQueryWrapper);
-                List<String> gameCodes = new ArrayList<>();
-                for (GameRecommendationRecord gameRecommendationRecord : gameRecommendationRecordList) {
-                    gameCodes.addAll(Arrays.stream(gameRecommendationRecord.getGameCodes().split(",")).collect(Collectors.toList()));
-                }
-                Map<String,Game> gameMap = new HashMap<>();
-                // 测评有问题的 类型的所有游戏
-                for (String type : typeSet) {
-                    LambdaQueryWrapper<Game> gameLambdaQueryWrapper = new LambdaQueryWrapper<>();
-                    gameLambdaQueryWrapper.eq(Game::getGameType,type);
-                    List<Game> gameTypes = gameService.list(gameLambdaQueryWrapper);
-                    if (CollectionUtil.isNotEmpty(gameTypes)){
-                        Map<String, Game> map = gameTypes.stream().collect(Collectors.toMap(Game::getGameCode, game -> game));
-                        gameMap.putAll(map);
+                } else {
+                    // 不为空 获取对应认知域 难度的所有游戏 去除上次完成的游戏 后如果超过1个进行随机获取， 如果没有了 查询所以随机获取
+                    List<Game> excludeLastGame = new ArrayList<>();
+                    if (!tagGamesList1.isEmpty()){
+                        if (tagGamesList1.size() > 1){
+                            // 大于1 排除上次刚完成的游戏
+                            excludeLastGame = tagGamesList1.stream().filter(game -> !game.getGameCode().equals(gameUser.getGameCode())).collect(Collectors.toList());
+                        }else {
+                            excludeLastGame.addAll(tagGamesList1);
+                        }
+                        if (excludeLastGame.size() <= 1){
+                            gameList.addAll(excludeLastGame);
+                        }else{
+                            Collections.shuffle(excludeLastGame);
+                            gameList.add(excludeLastGame.get(0));
+                        }
+
+
                     }
                 }
-                // 清除已经推荐的游戏
-                gameCodes.forEach(gameMap::remove);
-                // 判断是否已经全部推荐过一次了
-                if (gameMap.isEmpty()){
-                    // 已全部推荐过一次 ，重新随机推荐
-                    frequency = one.getFrequency()+1;
-                    for (String type : typeSet) {
-                        LambdaQueryWrapper<Game> gameLambdaQueryWrapper = new LambdaQueryWrapper<>();
-                        gameLambdaQueryWrapper.eq(Game::getGameType,type).last("limit 1");
-                        Game game = gameService.getOne(gameLambdaQueryWrapper);
-                        if (ObjectUtils.isNotNull(game)){
-                            gameList.add(game);
+            }
+            if (gameUsers.isEmpty()){
+                lambdaQueryWrapper.orderByDesc(GameUser::getUpdateTime).last("limit 2");
+                List<GameUser> list = gameUserService.list(lambdaQueryWrapper);
+                if (list.isEmpty()){
+                    // 为空直接随机获取
+                    if (!tagGameList.isEmpty()){
+                        if (tagGameList.size() > 2){
+                            Collections.shuffle(tagGameList);
+                        }
+                        gameList.add(tagGameList.get(0));
+                        if (tagGameList.size()>1){
+                            gameList.add(tagGameList.get(1));
                         }
                     }
                 }else {
-                    // 从剩余的里面 根据缺陷类型各随机选取一款
-                    frequency = one.getFrequency();
-                    List<Game> games = gameMap.values().stream().collect(Collectors.toList());
-                    for (String type : typeSet) {
-                        int i = 0;
-                        for (Game game : games) {
-                            if (game.getGameType().equals(type)){
-                                if (i == 0){
-                                    gameList.add(game);
-                                    i++;
+                    if (!tagGameList.isEmpty()){
+                        if (tagGameList.size() > 2){
+                            if (tagGameList.size() == 3){
+                                List<Game> collect = tagGameList.stream().filter(game -> !game.getGameCode().equals(list.get(0).getGameCode())).collect(Collectors.toList());
+                                gameList.addAll(collect);
+                            }else {
+                                Set<String> gameCodesToDelete = list.stream()
+                                        .map(GameUser::getGameCode)
+                                        .collect(Collectors.toSet());
+                                List<Game> filteredGameList = tagGameList.stream()
+                                        .filter(game -> !gameCodesToDelete.contains(game.getGameCode()))
+                                        .collect(Collectors.toList());
+                                if (filteredGameList.size() > 2){
+                                    Collections.shuffle(filteredGameList);
                                 }
+                                gameList.add(filteredGameList.get(0));
+                                if (filteredGameList.size()>1){
+                                    gameList.add(filteredGameList.get(1));
+                                }
+                            }
+                        }else {
+                            gameList.add(tagGameList.get(0));
+                            if (tagGameList.size()>1){
+                                gameList.add(tagGameList.get(1));
                             }
                         }
                     }
-                }
 
+                }
             }
-        }else {
-            // 为空 代表该评估任务没有推荐记录 随机进行推荐
-            if (typeSet.size() == 0){
-                return null;
-            }
-            for (String type : typeSet) {
-                LambdaQueryWrapper<Game> gameLambdaQueryWrapper = new LambdaQueryWrapper<>();
-                gameLambdaQueryWrapper.eq(Game::getGameType,type).last("limit 1");
-                Game game = gameService.getOne(gameLambdaQueryWrapper);
-                if (ObjectUtils.isNotNull(game)){
-                    gameList.add(game);
+        }
+        return gameList;
+    }
+
+
+    /**
+     * 判断推荐游戏的困难等级
+     * @param appUser
+     * @return
+     */
+    public String difficultyLevel(AppUser appUser) {
+        // 获取基础信息
+        Integer mentalEnergy = appUser.getMentalEnergy();
+        Integer age = appUser.getAge();
+        String education = appUser.getEducation();
+
+        // 根据脑力值获取难度
+        Integer gameDifficulty = getGameMentalEnergyDifficulty(mentalEnergy);
+
+        // 根据年龄调整难度
+        Integer gameAgeDifficulty = getGameAgeDifficulty(age);
+        if (gameAgeDifficulty < gameDifficulty) {
+            gameDifficulty--;
+        }
+
+        // 根据学历调整难度
+        Integer gameEducation = getGameEducation(education);
+        if (gameEducation < gameDifficulty) {
+            gameDifficulty--;
+        }
+        // 获取最近一次的 专属任务（原理疗任务）
+        LambdaQueryWrapper<GameTask> gameTaskWrapper = new LambdaQueryWrapper<>();
+        gameTaskWrapper.eq(GameTask::getUserId,appUser.getId());
+        gameTaskWrapper.orderByDesc(GameTask::getTaskStartTime).last("limit 7");
+        List<GameTask> list = gameTaskService.list(gameTaskWrapper);
+        // 判断7天内 用户游戏是否全部无法通关
+        if (!list.isEmpty() && list.size() == 7) {
+            List<Long> ids = list.stream().map(gameTask -> gameTask.getId()).collect(Collectors.toList());
+            LambdaQueryWrapper<GameTaskDetail> lambdaQueryWrapper = new LambdaQueryWrapper<>();
+            lambdaQueryWrapper.in(GameTaskDetail::getTaskId,ids);
+            long gameTaskDetailCount = gameTaskDetailService.count(lambdaQueryWrapper);
+            lambdaQueryWrapper.eq(GameTaskDetail::getStatus,"0");
+            long gameTaskDetailByStatusCount = gameTaskDetailService.count(lambdaQueryWrapper);
+            if (gameTaskDetailCount == gameTaskDetailByStatusCount){
+                lambdaQueryWrapper.eq(GameTaskDetail::getIsPass,"0");
+                long count = gameTaskDetailService.count(lambdaQueryWrapper);
+                if (count == 0 && gameDifficulty != 1) {
+                    gameDifficulty--;
                 }
             }
         }
 
-        gameRecommendationRecordService.saveBatch(gameList,appUser.getId(),"A",reviewTaskId,recommendNum,frequency);
 
-        return gameList;
+        // 根据调整后的难度返回对应的等级
+        switch (gameDifficulty) {
+            case 1:
+                return "A";
+            case 2:
+                return "B";
+            default:
+                return "C";
+        }
     }
 
     /**
-     * 推荐 认知训练游戏
-     * @param appUser
+     * 根据学历获取困难等级
+     * @param education
      * @return
      */
-    private List<Game> recommendationB(AppUser appUser) {
-        List<Game> gameList = new ArrayList<>();
-        return gameList;
+    public Integer getGameEducation(String education){
+        if (ObjectUtils.isNull(education)){
+            return 1;
+        }
+        if (education.equals("A")) {
+            return 1;
+        }else if (education.equals("B")) {
+            return 2;
+        } else if (education.equals("C")){
+            return 3;
+        }
+        return 1;
+    }
+
+    /**
+     * 根据脑力值获取困难程度
+     * @param mentalEnergy
+     * @return
+     */
+    public Integer getGameMentalEnergyDifficulty(Integer mentalEnergy){
+        if(mentalEnergy == null){
+            mentalEnergy = 0;
+        }
+        if(mentalEnergy< 300){
+            return 1;
+        }else if(mentalEnergy > 300 && mentalEnergy < 500){
+            return 2;
+        }else if(mentalEnergy > 500 && mentalEnergy <= 1000){
+            return 3;
+        }
+        return 1;
     }
+
+    /**
+     * 根据年龄获取困难程度
+     */
+    public Integer getGameAgeDifficulty(Integer age){
+        if (age == null){
+            return 1;
+        }
+        if (age > 70){
+            return 1;
+        } else if (age <= 70 && age > 60) {
+            return 2;
+        } else if (age <= 60){
+            return 3;
+        }
+        return 1;
+    }
+
+
 }

hcp-core/src/main/java/com/yingyangfly/core/service/impl/GamePlayRecordServiceImpl.java

@@ -52,29 +52,29 @@ import java.util.concurrent.ThreadPoolExecutor;
 @Slf4j
 public class GamePlayRecordServiceImpl implements GamePlayRecordService {
 
-    @Autowired
+    @Resource
     private TokenUtil tokenUtil;
-    @Autowired
+    @Resource
     private GameService gameService;
-    @Autowired
+    @Resource
     private GamePlayRecordMapper gamePlayRecordMapper;
-    @Autowired
+    @Resource
     private MongoTemplate mongoTemplate;
-    @Autowired
+    @Resource
     private GameUserService gameUserService;
-    @Autowired
+    @Resource
     private GameUserMapper gameUserMapper;
-    @Autowired
+    @Resource
     private GameTaskMapper gameTaskMapper;
-    @Autowired
+    @Resource
     private GameTaskDetailMapper gameTaskDetailMapper;
-    @Autowired
+    @Resource
     private AppUserMapper appUserMapper;
-    @Autowired
+    @Resource
     private MentalEnergyDetailMapper mentalEnergyDetailMapper;
-    @Autowired
+    @Resource
     private MentalEnergyDetailRecordMapper mentalEnergyDetailRecordMapper;
-    @Autowired
+    @Resource
     MsgWarnService msgWarnService;
     @Value("${query-daily-trai}")
     private String queryDailyTrai;
@@ -170,6 +170,7 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
             gamePlayRecord.setCreateBy(appCurrentLoginUser.getName());
             gamePlayRecord.setOrgCode(appCurrentLoginUser.getOrgCode());
             gamePlayRecord.setOrgName(appCurrentLoginUser.getOrgName());
+            gamePlayRecord.setDelFlag(0);
             try{
                 mongoTemplate.save(gamePlayRecord,"game_play_record");
                 log.info("<<<<<<<<<<<<<异步保存游戏记录结束:{}>>>>>>>>>>>>>>");
@@ -276,7 +277,7 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
 
         Criteria criteria = Criteria.where("user_id").is(userId)
                                                      .and("game_code").is(gameCode)
-                                                     .and("play_class").is(playClass);
+                                                     .and("play_class").is(playClass).and("del_flag").is(0);;
         Aggregation aggregation = Aggregation.newAggregation(
                 Aggregation.match(criteria),
                 Aggregation.group("userId").sum("game_score").as("gameScore")
@@ -293,7 +294,8 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
 
         Criteria criteria = Criteria.where("user_id").is(userId)
                 .and("game_code").is(gameCode)
-                .and("play_class").is(playClass);
+                .and("play_class").is(playClass)
+                .and("del_flag").is(0);
         Aggregation aggregation = Aggregation.newAggregation(
                 Aggregation.match(criteria),
                 Aggregation.group("userId").sum("game_score").as("gameScore")
@@ -329,7 +331,9 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
         AppCurrentLoginUser appCurrentLoginUser = tokenUtil.getAppCurrentLoginUser();
         Criteria criteria = Criteria.where("user_id").is(appCurrentLoginUser.getId())
                 .and("game_code").is(gameCode)
-                .and("play_class").is(playClass);
+                .and("play_class").is(playClass)
+                .and("is_pass").is("0")
+                .and("del_flag").is(0);
 
         Aggregation aggregation = Aggregation.newAggregation(
                 Aggregation.match(criteria),
@@ -374,7 +378,7 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
      */
     @Override
     public Integer sumMaxScoreByGameCode(String gameCode, String playClass,String orgCode) {
-        Criteria criteria = Criteria.where("game_code").is(gameCode).and("org_code").is(orgCode).and("play_class").is(playClass);
+        Criteria criteria = Criteria.where("game_code").is(gameCode).and("org_code").is(orgCode).and("play_class").is(playClass).and("del_flag").is(0);
 
         Aggregation aggregation = Aggregation.newAggregation(
                 Aggregation.match(criteria),
@@ -392,11 +396,11 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
 
         Criteria criteria = null;
         if(StringUtils.isEmpty(time)){
-            criteria  = Criteria.where("user_id").is(userId);
+            criteria  = Criteria.where("user_id").is(userId).and("del_flag").is(0);
         }else{
             Date startDate = DateUtils.parseDate(time+" 00:00:00");
             Date endDate = DateUtils.parseDate(time+" 23:59:59");
-            criteria  = Criteria.where("user_id").is(userId).and("create_time").gte(startDate).lte(endDate);
+            criteria  = Criteria.where("user_id").is(userId).and("create_time").gte(startDate).lte(endDate).and("del_flag").is(0);
         }
         Aggregation aggregation = Aggregation.newAggregation(
                 Aggregation.match(criteria),
@@ -478,7 +482,7 @@ public class GamePlayRecordServiceImpl implements GamePlayRecordService {
 
         Criteria criteria = Criteria.where("user_id").is(userId)
                                    .and("play_class").in(playClass.split(","))
-                                   .and("create_time").gte(DateUtils.parseDate(time+" 00:00:00")).lte(DateUtils.parseDate(time+" 23:59:59"));
+                                   .and("create_time").gte(DateUtils.parseDate(time+" 00:00:00")).lte(DateUtils.parseDate(time+" 23:59:59")).and("del_flag").is(0);
 
         Aggregation aggregation = Aggregation.newAggregation(
                 Aggregation.match(criteria),

hcp-core/src/main/java/com/yingyangfly/core/service/impl/GameUserServiceImpl.java

@@ -18,10 +18,14 @@ import com.yingyangfly.core.service.*;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.BeanUtils;
-import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import javax.annotation.Resource;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -35,29 +39,32 @@ import java.util.stream.Collectors;
 @Slf4j
 public class GameUserServiceImpl extends ServiceImpl<GameUserMapper, GameUser> implements GameUserService {
 
-    @Autowired
+    @Resource
     private GameUserMapper gameUserMapper;
-    @Autowired
+    @Resource
     private GameMapper gameMapper;
-    @Autowired
+    @Resource
     private TokenUtil tokenUtil;
-    @Autowired
+    @Resource
     private SysDictDataService sysDictDataService;
-    @Autowired
+    @Resource
     private GameTaskDetailMapper gameTaskDetailMapper;
-    @Autowired
+    @Resource
     private GameTaskService gameTaskService;
-    @Autowired
+    @Resource
     private GameRecommendRecordService gameRecommendRecordService;
-    @Autowired
+    @Resource
     private AppUserService appUserService;
-    @Autowired
+    @Resource
     private GamePlayRecordMapper gamePlayRecordMapper;
-    @Autowired
+    @Resource
     private GameTaskMapper gameTaskMapper;
-    @Autowired
+    @Resource
     private MsgWarnService warnService;
 
+    @Resource
+    private MongoTemplate mongoTemplate;
+
     @Override
     public GameUser selectByGameCodeAndUserIdAndPlayClassAndStatus(String gameCode, Long userId,String playClass,String status) {
         QueryWrapper<GameUser> queryWrapper = new QueryWrapper<>();
@@ -287,17 +294,31 @@ public class GameUserServiceImpl extends ServiceImpl<GameUserMapper, GameUser> i
         gameUser.setCurrentLevel(1);
         gameUser.setUpdateTime(new Date());
         gameUserMapper.updateById(gameUser);
-        gamePlayRecordMapper.deleteByUserIdAndPlayClassAndGameCode(gameUser.getUserId(),gameUser.getPlayClass(),gameUser.getGameCode());
 
+        Criteria criteria = Criteria.where("game_code").is(gameUser.getGameCode()).and("user_id").is(gameUser.getUserId()).and("play_class").is(gameUser.getPlayClass()).and("del_flag").is(0);
+        Query query = new Query(criteria);
+        Update update = new Update().set("del_flag",1);
+
+        mongoTemplate.updateMulti(query,update,GamePlayRecord.class);
+//        gamePlayRecordMapper.deleteByUserIdAndPlayClassAndGameCode(gameUser.getUserId(),gameUser.getPlayClass(),gameUser.getGameCode());
     }
 
     @Override
+    @Transactional(rollbackFor = Exception.class)
     public void removeDelUserGameDone() {
         LambdaQueryWrapper<GameUser> queryWrapper = new LambdaQueryWrapper<>();
         queryWrapper.eq(GameUser::getStatus,"0");
         queryWrapper.eq(GameUser::getPlayClass,"B");
         GameUser gameUser = new GameUser();
         gameUser.setStatus("99");
+        List<GameUser> gameUserList = gameUserMapper.selectList(queryWrapper);
+        for (GameUser gameUserMongodb : gameUserList) {
+            Criteria criteria = Criteria.where("game_code").is(gameUserMongodb.getGameCode()).and("user_id").is(gameUserMongodb.getUserId()).and("play_class").is(gameUserMongodb.getPlayClass()).and("del_flag").is(0);
+            Query query = new Query(criteria);
+            Update update = new Update().set("del_flag",1);
+
+            mongoTemplate.updateMulti(query,update,GamePlayRecord.class);
+        }
         int updateCount = gameUserMapper.update(gameUser, queryWrapper);
         log.info("<<<<<<<<<<<<<<定时任务更用户状态为历史，条数为:{}>>>>>>>>>>>>>",updateCount);
     }

hcp-platform/src/main/java/com/yingyangfly/platform/job/RemoveDelUserGameJob.java

@@ -17,7 +17,7 @@ public class RemoveDelUserGameJob {
 
     public void run()  {
         log.info("<<<<<<<<<<<<<<<<删除已经通关数据开始>>>>>>>>>>>>>>>>>>");
-        gameUserService.removeDelUserGameDone();
+//        gameUserService.removeDelUserGameDone();
         log.info("<<<<<<<<<<<<<<<<删除已经通关数据结束>>>>>>>>>>>>>>>>>>");
     }
 }