hy/aslan-server
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

每日任务功能优化

Browse Source
This commit is contained in:
tianfeng 2025-10-23 15:59:37 +08:00
parent 1a52d8b482
commit d448123b7c
5 changed files with 384 additions and 646 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
rc-service/rc-service-other/other-application/src/main/java/com/red/circle/other/app/listener/gift/strategy/GiftCountStrategy.java
View File

@ -17,6 +17,7 @@ import com.red.circle.other.app.common.gift.GameLuckyGiftCommon;
import com.red.circle.other.app.dto.clientobject.game.GameRoomPkUserCO;
import com.red.circle.other.app.dto.cmd.SpinsTaskProgressUpdateCmd;
import com.red.circle.other.app.service.SpinsUserTaskProgressService;
import com.red.circle.other.app.util.DateTimeAsiaRiyadhUtils;
import com.red.circle.other.domain.gateway.user.UserProfileGateway;
import com.red.circle.other.domain.gateway.user.ability.UserRegionGateway;
import com.red.circle.other.domain.model.user.UserProfile;
@ -805,7 +806,7 @@ public class GiftCountStrategy implements GiftStrategy {
if (StringUtils.isBlank(countStr)) {
// 计算到凌晨的过期时间（秒）
long expireSeconds = getSecondsUntilMidnight();
long expireSeconds = DateTimeAsiaRiyadhUtils.getSecondsUntilMidnight();
redisService.setString(redisKey, "1", expireSeconds, TimeUnit.SECONDS);
return 1;
} else {
@ -814,14 +815,4 @@ public class GiftCountStrategy implements GiftStrategy {
}
}
/**
* 获取当前时间到凌晨的秒数
* @return 秒数
*/
private long getSecondsUntilMidnight() {
ZonedDateTime now = ZonedDateTimeAsiaRiyadhUtils.now();
ZonedDateTime midnight = now.toLocalDate().plusDays(1).atStartOfDay(now.getZone());
return java.time.Duration.between(now, midnight).getSeconds();
}
}

359
rc-service/rc-service-other/other-application/src/main/java/com/red/circle/other/app/listener/task/TaskListener.java
View File

@ -3,7 +3,6 @@ package com.red.circle.other.app.listener.task;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.google.common.base.Throwables;
import com.red.circle.common.business.core.enums.SysOriginPlatformEnum;
import com.red.circle.common.business.dto.cmd.AppExtCommand;
import com.red.circle.common.business.enums.SendPropsOrigin;
import com.red.circle.component.mq.MessageEventProcess;
import com.red.circle.component.mq.MessageEventProcessDescribe;
@ -13,25 +12,19 @@ import com.red.circle.component.mq.service.ConsumerMessage;
import com.red.circle.component.mq.service.MessageListener;
import com.red.circle.component.redis.service.RedisService;
import com.red.circle.external.inner.endpoint.message.ImGroupClient;
import com.red.circle.external.inner.model.cmd.message.BroadcastGroupMsgBodyCmd;
import com.red.circle.external.inner.model.enums.message.GroupMessageTypeEnum;
import com.red.circle.mq.business.model.event.task.TaskApprovalEvent;
import com.red.circle.mq.rocket.business.streams.TaskSink;
import com.red.circle.other.app.dto.clientobject.game.GameRoomMessageCO;
import com.red.circle.other.app.dto.cmd.SpinsTaskProgressUpdateCmd;
import com.red.circle.other.app.service.SpinsUserTaskProgressService;
import com.red.circle.other.app.service.room.RoomProfileService;
import com.red.circle.other.app.service.task.TaskService;
import com.red.circle.other.app.util.DateTimeAsiaRiyadhUtils;
import com.red.circle.other.domain.gateway.user.UserProfileGateway;
import com.red.circle.other.domain.gateway.user.ability.InviteUserGateway;
import com.red.circle.other.domain.model.user.UserConsumptionLevel;
import com.red.circle.other.domain.model.user.UserProfile;
import com.red.circle.other.infra.database.rds.dao.h5.UserInviteTaskRecordDAO;
import com.red.circle.other.infra.database.rds.dao.user.user.UserInviteUserDAO;
import com.red.circle.other.infra.database.rds.entity.family.FamilyMemberInfo;
import com.red.circle.other.infra.database.rds.entity.h5.UserInviteTaskRecord;
import com.red.circle.other.infra.database.rds.entity.sys.EnumConfig;
import com.red.circle.other.infra.database.rds.entity.user.user.CpRelationship;
import com.red.circle.other.infra.database.rds.entity.user.user.LatestMobileDevice;
import com.red.circle.other.infra.database.rds.entity.user.user.UserInviteUser;
import com.red.circle.other.infra.database.rds.enums.h5.MemberActiveEnum;
@ -56,7 +49,6 @@ import java.sql.Timestamp;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
@ -69,22 +61,6 @@ public class TaskListener implements MessageListener {
private final TaskService taskService;
private final RedisService redisService;
private final RelationshipFriendService relationshipFriendService;
private final FamilyMemberInfoService familyMemberInfoService;
private final CpRelationshipService cpRelationshipService;
private final UserProfileGateway userProfileGateway;
private final RoomProfileService roomProfileService;
private final LatestMobileDeviceService lastestMobileDeviceService;
private final UserInviteTaskRecordDAO userInviteTaskRecordDAO;
private final UserInviteUserDAO userInviteUserDAO;
private final PropsActivityClient propsActivityCnfClient;
private final EnumConfigService enumConfigService;
private final ImGroupClient imGroupClient;
private final GameListConfigService gameListConfigService;
private final InviteUserGateway inviteUserGateway;
private final SpinsUserTaskProgressService spinsUserTaskProgressService;
@ -113,61 +89,37 @@ public class TaskListener implements MessageListener {
handleTask2(eventBody);
break;
case 3:
// 处理任务-3 的逻辑 添加3个好友
// 处理任务-3 的逻辑 在商店购买任意商品
handleTask3(eventBody);
// 处理任务-12 的逻辑 添加20个好友
eventBody.setTaskId(12);
handleTask12(eventBody);
break;
case 4:
// 处理任务-4 的逻辑 玩一局游戏
handleTask4(eventBody);
break;
case 5:
// 处理任务-5 的逻辑 发布一条动态
// 处理任务-5 的逻辑 创建我的房间
handleTask5(eventBody);
break;
case 6:
// 处理任务-6 的逻辑 创建或加入一个家族
// 处理任务-6 的逻辑 添加10个好友
handleTask6(eventBody);
break;
case 7:
// 处理任务-7 的逻辑 组成一对CP
// 处理任务-7 的逻辑 加入3个房间
handleTask7(eventBody);
break;
case 8:
// 处理任务-8 的逻辑 在商店购买任意商品
// 处理任务-8 的逻辑 发送10个幸运礼物
handleTask8(eventBody);
break;
case 9:
// 处理任务-9 的逻辑 首次充值
// 处理任务-9 的逻辑 关注一个用户
handleTask9(eventBody);
break;
case 10:
// 处理任务-10 的逻辑 加入3个房间
// 处理任务-9 的逻辑 关注一个房间
handleTask10(eventBody);
break;
case 11:
// 处理任务-11 的逻辑 创建我的房间
handleTask11(eventBody);
break;
case 12:
// 处理任务-12 的逻辑 添加20个好友
handleTask12(eventBody);
break;
case 13:
// 处理任务-13 的逻辑 财富等级达到10级
handleTask13(eventBody);
break;
case 14:
// 处理任务-14 的逻辑 魅力等级达到10级
handleTask14(eventBody);
break;
// case 99:
// // 处理任务-99 裂变任务 的逻辑 注册
// handleTask99(eventBody);
// break;
default:
// 处理未知任务 ID 的情况
handleUnknownTask(taskId);
@ -176,12 +128,22 @@ public class TaskListener implements MessageListener {
);
}
private void handleTask1(TaskApprovalEvent eventBody) {
private void handleTask10(TaskApprovalEvent eventBody) {
}
private void handleTask8(TaskApprovalEvent eventBody) {
}
private void handleTask1(TaskApprovalEvent eventBody) {
// // 增加心跳次数 放一天
String redisKey = "mic:heartbeat:" + eventBody.getUserId();
String inc = redisService.getString(redisKey);
if (StringUtils.isEmpty(inc)) {
redisService.increment(redisKey, 1, 1, TimeUnit.DAYS);
// 计算到凌晨的过期时间（秒）
long expireSeconds = DateTimeAsiaRiyadhUtils.getSecondsUntilMidnight();
redisService.increment(redisKey, 1, expireSeconds, TimeUnit.SECONDS);
} else {
//大于10次发一个消息
if ("10".equals(inc) || Integer.parseInt(inc) >= 10) {
@ -254,139 +216,14 @@ public class TaskListener implements MessageListener {
}
}
private void handleTask99(TaskApprovalEvent eventBody) {
log.warn("处理任务-99 裂变注册任务: {}", eventBody);
// LatestMobileDevice userDevice = lastestMobileDeviceService.getByUserId(eventBody.getUserId());
// if (Objects.isNull(userDevice)) {
// log.warn("裂变注册任务 用户设备未注册: {}", eventBody.getUserId());
// return;
// }
// Long ipCount = lastestMobileDeviceService.getCountByImeiAndIp(eventBody.getImei(), eventBody.getIp(),SysOriginPlatformEnum.valueOf("LOTFUN").getSysOrigin());
// if (ipCount>1) {
// log.warn("裂变注册任务 用户设备已注册: {}", eventBody.getUserId());
// return;
// }
// lastestMobileDeviceService.getByUserId(eventBody.getUserId());
// //判断当前user ip 和 imei是否注册
// //初始化任务
LambdaQueryWrapper<UserInviteUser> query = new LambdaQueryWrapper<>();
query.eq(UserInviteUser::getUserId, eventBody.getUserId());
UserInviteUser userInviteUser = userInviteUserDAO.selectList(query).get(0);
if (!Objects.isNull(userInviteUser)) {
List<UserInviteUser> userInviteUserList = userInviteUserDAO.selectList(new LambdaQueryWrapper<UserInviteUser>().eq(UserInviteUser::getInviteUserId, userInviteUser.getInviteUserId()));
if (!CollectionUtils.isEmpty(userInviteUserList)) {
List<LatestMobileDevice> devices = lastestMobileDeviceService.getByUserId(userInviteUserList.stream().map(UserInviteUser::getUserId).collect(Collectors.toSet()));
if (!CollectionUtils.isEmpty(devices)) {
// 判断ip是否注册
boolean ipExists = devices.stream()
.anyMatch(device -> device.getIp().equals(eventBody.getIp()));
if (ipExists) {
log.warn("裂变注册任务 用户ip已注册: {}", eventBody);
return;
}
// 判断imei是否注册
boolean imeiExists = devices.stream()
.anyMatch(device -> device.getImei().equals(eventBody.getImei()));
if (imeiExists) {
log.warn("裂变注册任务 用户设备已注册: {}", eventBody);
return;
}
}
}
List<UserInviteTaskRecord> taskRecordList = MemberActiveEnum.getTasksByType(1).stream().map(active -> {
UserInviteTaskRecord record = new UserInviteTaskRecord();
record.setUserId(eventBody.getUserId());
record.setInviteUserId(userInviteUser.getInviteUserId());
record.setTaskId((long) active.getTaskId());
record.setTaskStatus(0);
record.setRewardId(active.getRewardId());
record.setTaskType(1);
record.setCreateTimestamp(TimestampUtils.now());
return record;
}).toList();
List<UserInviteTaskRecord> insertList = new ArrayList<>(taskRecordList);
long l = checkInitInviteUserTask(userInviteUser);
if (l == 0) {
//初始化邀请人任务
List<UserInviteTaskRecord> taskInviteUserRecordList = MemberActiveEnum.getTasksByType(2).stream().map(active -> {
UserInviteTaskRecord record = new UserInviteTaskRecord();
record.setUserId(userInviteUser.getInviteUserId());
// record.setInviteUserId();
record.setTaskId((long) active.getTaskId());
record.setRewardId(active.getRewardId());
record.setTaskStatus(0);
record.setTaskType(2);
record.setCreateTimestamp(TimestampUtils.now());
return record;
}).toList();
insertList.addAll(taskInviteUserRecordList);
}
userInviteTaskRecordDAO.insertBatchSomeColumn(insertList);
checkMemberActive(eventBody.getUserId(), MemberActiveEnum.TASK_1);
}
}
private long checkInitInviteUserTask(UserInviteUser userInviteUser) {
//是否初始化过
LambdaQueryWrapper<UserInviteTaskRecord> inviteUserquery = new LambdaQueryWrapper<>();
inviteUserquery.eq(UserInviteTaskRecord::getUserId, userInviteUser.getInviteUserId());
inviteUserquery.eq(UserInviteTaskRecord::getTaskType, 2);
return userInviteTaskRecordDAO.selectCount(inviteUserquery);
}
//裂变任务校验
private void checkMemberActive(Long userId, MemberActiveEnum activeEnum) {
LambdaQueryWrapper<UserInviteTaskRecord> query = new LambdaQueryWrapper<>();
int taskId = activeEnum.getTaskId();
query.in(UserInviteTaskRecord::getUserId, userId);
query.eq(UserInviteTaskRecord::getTaskId, taskId);
query.eq(UserInviteTaskRecord::getTaskStatus, 0);
LocalDate localDate = LocalDate.of(2025, 6, 25);
Timestamp timestamp = LocalDateUtils.convertTimestamp(localDate);
query.ge(UserInviteTaskRecord::getCreateTimestamp, timestamp);
String lockKey = "task::member-active:reward:" + userId + "-" + taskId;
try {
if (redisService.lock(lockKey, 20)) {
List<UserInviteTaskRecord> record = userInviteTaskRecordDAO.selectList(query);
if (!record.isEmpty()) {
record.get(0).setTaskStatus(1);
record.get(0).setCompletedTime(TimestampUtils.now());
userInviteTaskRecordDAO.updateById(record.get(0));
// 发送道具
propsActivityCnfClient.sendActivityReward(new SendActivityRewardCmd()
.setTrackId(IdWorkerUtils.getId())
.setSysOrigin(SysOriginPlatformEnum.valueOf(SysOriginPlatformEnum.valueOf("LOTFUN").getSysOrigin()))
.setAcceptUserId(record.get(0).getInviteUserId())
.setSourceGroupId(activeEnum.getRewardId())
.setOrigin(SendPropsOrigin.MEMBER_ACTIVE_TASK_REWARD)
);
}
}
} finally {
redisService.unlock(lockKey);
}
}
private void handleTask2(TaskApprovalEvent eventBody) {
log.warn("处理任务-2 在房间内赠送礼物: {}", eventBody);
// 更新任务状态的逻辑 直接更新
updateTaskStatus(eventBody);
}
private void handleTask3(TaskApprovalEvent eventBody) {
log.warn("处理任务-3 添加3个好友: {}", eventBody);
private void handleTask6(TaskApprovalEvent eventBody) {
log.warn("处理任务-6 添加10个好友: {}", eventBody);
// 更新任务状态的逻辑
if (relationshipFriendService.todayFlowSize(eventBody.getUserId()) >= 3) {
updateTaskStatus(eventBody);
@ -400,82 +237,6 @@ public class TaskListener implements MessageListener {
log.warn("处理任务-4 玩一局游戏: {}", eventBody);
// 更新任务状态的逻辑
updateTaskStatus(eventBody);
// 增加IM通知
sendImGroup(eventBody);
}
/**
* 当玩家中奖大于一定金币数量时,发通知
* @param eventBody
*/
private void sendImGroup(TaskApprovalEvent eventBody) {
log.warn("{} 发送游戏获奖通知:金币数量= {}", eventBody.getGameName(), eventBody.getCurrencyDiff());
if (eventBody.getCurrencyDiff() == null || eventBody.getCurrencyDiff() < 0) {
return;
}
EnumConfig enumConfig = enumConfigService.getByEnumConfig("GAME_IM_NOTIFICATION_PRICE", eventBody.getSysOrigin());
Long value = convertStringToLong(enumConfig.getVal());
log.warn("发送游戏获奖通知--配置数据:{}", value);
if (value == null) {
log.warn("{} 发送游戏获奖通知:未查询到配置数据", eventBody.getGameName());
return;
}
if (eventBody.getCurrencyDiff() < value) {
log.warn("{} 发送游戏获奖通知:游戏获奖金币低于配置值,不发送通知", eventBody.getGameName());
return;
}
UserProfile userProfile = userProfileGateway.getByUserId(eventBody.getUserId());
if (userProfile == null || StringUtils.isBlank(userProfile.getUserAvatar())) {
log.warn("{} 发送游戏获奖通知:用户头像为空 = {}", eventBody.getGameName(), eventBody.getUserId());
}
// 查询游戏头像
String gameCover = gameListConfigService.getCoverByGameId(String.valueOf(eventBody.getGameId()),
mapGameName(eventBody.getGameName()), eventBody.getSysOrigin());
log.warn("发送游戏获奖通知--游戏头像:{}", gameCover);
imGroupClient.sendMessageBroadcast(
BroadcastGroupMsgBodyCmd
.builder()
.type(GroupMessageTypeEnum.GAME_BROADCAST)
.data(new GameRoomMessageCO()
.setGameCover(gameCover)
.setCurrencyDiff(eventBody.getCurrencyDiff())
.setUserCover(userProfile != null ? userProfile.getUserAvatar() : "")
.setMsgType(GroupMessageTypeEnum.GAME_BROADCAST.name()))
.toPlatform(SysOriginPlatformEnum.valueOf(eventBody.getSysOrigin()))
.build()
);
log.warn("{} 发送游戏获奖通知 成功,用户ID = {}", eventBody.getGameName(), eventBody.getUserId());
}
public static String mapGameName(String input) {
if (input == null || input.isEmpty()) {
return "";
}
char firstChar = Character.toUpperCase(input.charAt(0));
return switch (firstChar) {
case 'B' -> "BAISHUN";
case 'H' -> "HOTGAME";
case 'L' -> "LINGXIAN";
default -> "";
};
}
public static Long convertStringToLong(String str) {
try {
return Long.parseLong(str);
} catch (NumberFormatException e) {
return null;
}
}
private void handleTask5(TaskApprovalEvent eventBody) {
// 具体的任务 5 处理逻辑 直接更新
log.warn("处理任务-5 发布一条动态: {}", eventBody);
// 更新任务状态的逻辑
updateTaskStatus(eventBody);
}
private void handleUnknownTask(Integer taskId) {
@ -490,41 +251,16 @@ public class TaskListener implements MessageListener {
log.warn("任务已完成 {}", event);
}
// 成长任务 更新任务状态的方法示例
private void updateTaskStatusV2(TaskApprovalEvent event) {
if (taskService.checkTaskStatus(event.getUserId(), Long.valueOf(event.getTaskId()))) {
taskService.updateTaskStatus(1, event.getUserId(), Long.valueOf(event.getTaskId()));
}
log.warn("任务已完成 {}", event);
}
private void handleTask6(TaskApprovalEvent eventBody) {
log.warn("处理任务6 创建或加入一个家族: {}", eventBody);
FamilyMemberInfo familyMemberInfo = familyMemberInfoService.getFamilyMemberByUserId(eventBody.getUserId());
if (!Objects.isNull(familyMemberInfo)) {
updateTaskStatusV2(eventBody);
}
}
private void handleTask7(TaskApprovalEvent eventBody) {
log.warn("处理任务-7 组成一对CP: {}", eventBody);
// CpRelationship cp = cpRelationshipService.getByUserId(eventBody.getUserId());
// if (!Objects.isNull(cp)) {
// }
updateTaskStatusV2(eventBody);
}
private void handleTask8(TaskApprovalEvent eventBody) {
log.warn("处理任务-8: {}", eventBody);
private void handleTask3(TaskApprovalEvent eventBody) {
log.warn("处理任务-3: {}", eventBody);
// 在商店购买任意商品
updateTaskStatusV2(eventBody);
updateTaskStatus(eventBody);
}
private void handleTask9(TaskApprovalEvent eventBody) {
log.warn("处理任务-9: {}", eventBody);
// 首次充值
// updateTaskStatusV2(eventBody);
// updateTaskStatus(eventBody);
// checkMemberActive(eventBody.getUserId(), MemberActiveEnum.TASK_3);
// 如果是币商给用户充值
dealRechargeCommission(eventBody);
@ -540,7 +276,7 @@ public class TaskListener implements MessageListener {
}
}
private void handleTask10(TaskApprovalEvent eventBody) {
private void handleTask7(TaskApprovalEvent eventBody) {
log.warn("处理任务-10 加入3个房间: {}", eventBody);
// // 进入一次 +1
String redisKey = "task:add-room::" + eventBody.getUserId();
@ -551,53 +287,20 @@ public class TaskListener implements MessageListener {
//大于3次完成
if ("3".equals(inc)) {
// 更新任务状态的逻辑 直接更新
updateTaskStatusV2(eventBody);
updateTaskStatus(eventBody);
} else {
redisService.increment(redisKey, 1);
}
}
}
private void handleTask11(TaskApprovalEvent eventBody) {
log.warn("处理任务-11 创建我的房间: {}", eventBody);
private void handleTask5(TaskApprovalEvent eventBody) {
log.warn("处理任务-5 创建我的房间: {}", eventBody);
// AppExtCommand appExtCommand = new AppExtCommand();
// appExtCommand.setReqUserId(eventBody.getUserId());
// if (!Objects.isNull(roomProfileService.getRoomProfile(appExtCommand))) {
// }
updateTaskStatusV2(eventBody);
}
private void handleTask12(TaskApprovalEvent eventBody) {
log.warn("处理任务-12 添加20个好友: {}", eventBody);
// 更新任务状态的逻辑
if (relationshipFriendService.flowSize1000(eventBody.getUserId(), null, null).size() >= 20) {
updateTaskStatusV2(eventBody);
}
}
private void handleTask13(TaskApprovalEvent eventBody) {
log.warn("处理任务-13 财富等级达到10级: {}", eventBody);
UserConsumptionLevel userLevel = userProfileGateway.getUserConsumptionLevel(
SysOriginPlatformEnum.valueOf("LIKEI"),
eventBody.getUserId());
if (userLevel.getWealthLevel() >= 10) {
updateTaskStatusV2(eventBody);
}
}
private void handleTask14(TaskApprovalEvent eventBody) {
log.warn("处理任务-14 魅力等级达到10级: {}", eventBody);
UserConsumptionLevel userLevel = userProfileGateway.getUserConsumptionLevel(
SysOriginPlatformEnum.valueOf("LIKEI"),
eventBody.getUserId());
//魅力等级逻辑
if (userLevel.getCharmLevel() >= 10) {
updateTaskStatusV2(eventBody);
}
updateTaskStatus(eventBody);
}
}

593
rc-service/rc-service-other/other-application/src/main/java/com/red/circle/other/app/service/task/TaskServiceImpl.java
View File

@ -9,13 +9,10 @@ import com.red.circle.common.business.enums.SendPropsOrigin;
import com.red.circle.component.redis.service.RedisService;
import com.red.circle.other.app.dto.task.TaskDTO;
import com.red.circle.other.domain.gateway.user.UserProfileGateway;
import com.red.circle.other.domain.model.user.UserConsumptionLevel;
import com.red.circle.other.infra.database.rds.dao.task.TaskConfigDAO;
import com.red.circle.other.infra.database.rds.dao.task.UserTaskProgressDAO;
import com.red.circle.other.infra.database.rds.entity.family.FamilyMemberInfo;
import com.red.circle.other.infra.database.rds.entity.task.TaskConfig;
import com.red.circle.other.infra.database.rds.entity.task.UserTaskProgress;
import com.red.circle.other.infra.database.rds.entity.user.user.CpRelationship;
import com.red.circle.other.infra.database.rds.service.family.FamilyMemberInfoService;
import com.red.circle.other.infra.database.rds.service.user.user.CpRelationshipService;
import com.red.circle.other.inner.endpoint.activity.PropsActivityClient;
@ -31,25 +28,18 @@ import org.springframework.util.CollectionUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* 任务服务实现类
*/
@Service
@RequiredArgsConstructor
public class TaskServiceImpl implements TaskService {
private final TaskConfigDAO taskConfigDao;
private final UserTaskProgressDAO userTaskProgressDao;
private final PropsActivityClient propsActivityCnfClient;
private final FamilyMemberInfoService familyMemberInfoService;
private final CpRelationshipService cpRelationshipService;
private final UserProfileGateway userProfileGateway;
private final RedisService redisService;
// private final TeamMemberTargetService teamMemberTargetService;
/**
* 获取任务列表
*
@ -59,58 +49,60 @@ public class TaskServiceImpl implements TaskService {
@Override
public List<TaskDTO> getTaskList(AppExtCommand cmd) {
List<TaskDTO> resultList = new ArrayList<>();
//获取当前天 yyyy-mm-dd 格式
String date = DateUtil.format(new Date(), "yyyy-MM-dd");
Long userId = cmd.getReqUserId();
// 查询任务配置信息
//获取每日
// 查询任务配置信息（每日任务）
List<TaskConfig> taskConfigs = taskConfigDao.selectList(
new LambdaQueryWrapper<TaskConfig>()
.eq(TaskConfig::getTaskType, 1)
.orderByAsc(TaskConfig::getSortOrder));
Map<Long, TaskConfig> taskMapByIds = taskConfigs.stream().collect(Collectors.toMap(TaskConfig::getTaskId, taskConfig -> taskConfig));
// 每天有用户请求的时候创建对应的任务数据
Map<Long, TaskConfig> taskMapByIds = taskConfigs.stream()
.collect(Collectors.toMap(TaskConfig::getTaskId, taskConfig -> taskConfig));
// 创建每日任务（如果不存在）
List<UserTaskProgress> userTaskList = createDailyTasksIfNotExists(userId, taskConfigs, date);
if (CollectionUtils.isEmpty(userTaskList)) {
//新增list为空就是 已经创建过了 直接拼接
LambdaQueryWrapper<UserTaskProgress> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(UserTaskProgress::getUserId, userId);
queryWrapper.eq(UserTaskProgress::getDayString, date);
queryWrapper.eq(UserTaskProgress::getUserId, userId)
.eq(UserTaskProgress::getDayString, date);
userTaskList = userTaskProgressDao.selectList(queryWrapper);
}
Set<Long> rewardIds = taskConfigs.stream().map(TaskConfig::getRewardId).collect(Collectors.toSet());
//获取对应详情
Map<Long, ActivityPropsGroup> activityMap = propsActivityCnfClient.mapActivityPropsGroup(cmd.getReqSysOrigin().getOrigin(), rewardIds).getBody();
// 获取奖励详情
Set<Long> rewardIds = taskConfigs.stream()
.map(TaskConfig::getRewardId)
.collect(Collectors.toSet());
Map<Long, ActivityPropsGroup> activityMap = propsActivityCnfClient
.mapActivityPropsGroup(cmd.getReqSysOrigin().getOrigin(), rewardIds)
.getBody();
// 组装返回数据
userTaskList.forEach(item -> {
ActivityPropsGroup activity = activityMap.get(item.getRewardId());
// String taskDesc = messageSource.getMessage("task.task_"+item.getTaskId()+".desc", null, locale);
String taskDesc = ResourceBundle.getBundle("i18n.messages", new Locale(cmd.getReqLanguage())).getString("task.task_" + item.getTaskId() + ".desc");
String taskDesc = ResourceBundle.getBundle("i18n.messages", new Locale(cmd.getReqLanguage()))
.getString("task.task_" + item.getTaskId() + ".desc");
TaskDTO build = TaskDTO.builder()
.taskType(item.getTaskType())
.taskId(item.getTaskId())
// .taskDesc(taskMapByIds.get(item.getTaskId()).getTaskDesc())
.taskDesc(taskDesc)
.jumpPage(taskMapByIds.get(item.getTaskId()).getJumpPage())
.taskStatus(item.getTaskStatus())
.isRewardCollected(item.getIsRewardCollected())
.taskIcon(taskMapByIds.get(item.getTaskId()).getTaskIcon())
.taskStatus(item.getTaskStatus())
.conditionType(activity.getActivityRewardProps().get(0).getType())
.cover(activity.getActivityRewardProps().get(0).getCover())
.quantity(activity.getActivityRewardProps().get(0).getQuantity())
.build();
//拼接数据
// item.setActivityPropsGroup(activityMap.getData().get(item.getRewardId()));
// item.setDayString(date);
resultList.add(build);
});
//拼接任务
return resultList;
}
/**
* 获取任务状态
*
@ -120,78 +112,77 @@ public class TaskServiceImpl implements TaskService {
@Override
public Boolean getTaskStatus(Long userId) {
String date = DateUtil.format(new Date(), "yyyy-MM-dd");
LambdaQueryWrapper<UserTaskProgress> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(UserTaskProgress::getUserId, userId);
queryWrapper.eq(UserTaskProgress::getTaskStatus, 1);
queryWrapper.eq(UserTaskProgress::getIsRewardCollected, 0);
// queryWrapper.eq(UserTaskProgress::getDayString, date);
//所有的
queryWrapper.eq(UserTaskProgress::getUserId, userId)
.eq(UserTaskProgress::getTaskStatus, 1)
.eq(UserTaskProgress::getIsRewardCollected, 0);
List<UserTaskProgress> userTaskProgresses = userTaskProgressDao.selectList(queryWrapper);
// 检查是否有今日每日任务未领取
boolean todayTaskFlag = userTaskProgresses.stream()
.anyMatch(task -> task.getTaskType() == 1 && Objects.equals(task.getDayString(), date));
// 检查是否有成长任务未领取
boolean taskFlag = userTaskProgresses.stream()
.anyMatch(task -> task.getTaskType() == 2);
return todayTaskFlag || taskFlag;
}
/**
* 更新任务状态（优化后的单一方法）
*
* @param status 任务状态
* @param userId 用户ID
* @param taskId 任务ID
* @param date 日期（可选，每日任务需要传入，成长任务传null）
*/
@Override
public void updateTaskStatus(Integer status, Long userId, Long TaskId, String date) {
public void updateTaskStatus(Integer status, Long userId, Long taskId, String date) {
UserTaskProgress userTaskProgress = new UserTaskProgress();
// userTaskProgress.setTaskId(TaskId);
userTaskProgress.setTaskStatus(status);
LambdaUpdateWrapper<UserTaskProgress> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(UserTaskProgress::getUserId, userId);
updateWrapper.eq(UserTaskProgress::getTaskId, TaskId);
updateWrapper.eq(UserTaskProgress::getDayString, date);
int update = userTaskProgressDao.update(userTaskProgress, updateWrapper);
// List<UserTaskProgress> userTaskProgress = userTaskProgressDao.selectList(query);
updateWrapper.eq(UserTaskProgress::getUserId, userId)
.eq(UserTaskProgress::getTaskId, taskId);
// 如果传入了日期，说明是每日任务，需要加上日期条件
if (date != null && !date.isEmpty()) {
updateWrapper.eq(UserTaskProgress::getDayString, date);
}
userTaskProgressDao.update(userTaskProgress, updateWrapper);
}
/**
* 检查任务状态（优化后的单一方法）
*
* @param userId 用户ID
* @param taskId 任务ID
* @param date 日期（可选，每日任务需要传入，成长任务传null）
* @return true=未完成，false=已完成
*/
@Override
public void updateTaskStatus(Integer status, Long userId, Long TaskId) {
UserTaskProgress userTaskProgress = new UserTaskProgress();
// userTaskProgress.setTaskId(TaskId);
userTaskProgress.setTaskStatus(status);
LambdaUpdateWrapper<UserTaskProgress> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.eq(UserTaskProgress::getUserId, userId);
updateWrapper.eq(UserTaskProgress::getTaskId, TaskId);
int update = userTaskProgressDao.update(userTaskProgress, updateWrapper);
// List<UserTaskProgress> userTaskProgress = userTaskProgressDao.selectList(query);
}
@Override
public Boolean checkTaskStatus(Long userId, Long TaskId, String date) {
public Boolean checkTaskStatus(Long userId, Long taskId, String date) {
LambdaQueryWrapper<UserTaskProgress> query = new LambdaQueryWrapper<>();
query.eq(UserTaskProgress::getUserId, userId);
query.eq(UserTaskProgress::getTaskId, TaskId);
query.eq(UserTaskProgress::getTaskStatus, 1);
query.eq(UserTaskProgress::getDayString, date);
List<UserTaskProgress> userTaskProgress = userTaskProgressDao.selectList(query);
//get 0 true 未完成 false 已完成
return CollectionUtils.isEmpty(userTaskProgress);
query.eq(UserTaskProgress::getUserId, userId)
.eq(UserTaskProgress::getTaskId, taskId)
.eq(UserTaskProgress::getTaskStatus, 1);
// 如果传入了日期，说明是每日任务，需要加上日期条件
if (date != null && !date.isEmpty()) {
query.eq(UserTaskProgress::getDayString, date);
}
return userTaskProgressDao.selectCount(query) <= 0;
}
@Override
public Boolean checkTaskStatus(Long userId, Long TaskId) {
LambdaQueryWrapper<UserTaskProgress> query = new LambdaQueryWrapper<>();
query.eq(UserTaskProgress::getUserId, userId);
query.eq(UserTaskProgress::getTaskId, TaskId);
query.eq(UserTaskProgress::getTaskStatus, 1);
List<UserTaskProgress> userTaskProgress = userTaskProgressDao.selectList(query);
//get 0 true 未完成 false 已完成
return CollectionUtils.isEmpty(userTaskProgress);
}
/**
* 领取任务奖励
*
* @param cmd 命令对象
* @param taskId 任务 ID
* @return 操作结果
*/
@ -200,9 +191,11 @@ public class TaskServiceImpl implements TaskService {
String date = DateUtil.format(new Date(), "yyyy-MM-dd");
String lockKey = "task:reward:" + date + ":" + cmd.getReqUserId() + ":" + taskId;
List<TaskConfig> taskConfigs = taskConfigDao.selectList(new LambdaQueryWrapper<TaskConfig>().eq(TaskConfig::getTaskId, taskId));
List<TaskConfig> taskConfigs = taskConfigDao.selectList(
new LambdaQueryWrapper<TaskConfig>().eq(TaskConfig::getTaskId, taskId));
if (CollectionUtils.isEmpty(taskConfigs)) {
throw new RuntimeException("The task configuration does not exist.");
throw new RuntimeException("The task configuration does not exist.");
}
try {
@ -212,15 +205,18 @@ public class TaskServiceImpl implements TaskService {
.eq(UserTaskProgress::getTaskStatus, 1)
.eq(UserTaskProgress::getTaskId, taskId)
.eq(UserTaskProgress::getIsRewardCollected, 0);
// 每日任务需要判断日期
if (taskConfigs.get(0).getTaskType() == 1) {
//每日任务才需要时间
eq.eq(UserTaskProgress::getDayString, date);
}
List<UserTaskProgress> userTaskProgresses = userTaskProgressDao.selectList(eq);
if (CollectionUtils.isEmpty(userTaskProgresses)) {
throw new RuntimeException("There are no rewards to be claimed for the moment.");
throw new RuntimeException("There are no rewards to be claimed for the moment.");
}
UserTaskProgress userTaskProgress = userTaskProgresses.get(0);
// 发送道具
@ -235,7 +231,6 @@ public class TaskServiceImpl implements TaskService {
userTaskProgress.setIsRewardCollected(1);
userTaskProgress.setCompletedTime(TimestampUtils.now());
userTaskProgressDao.updateById(userTaskProgress);
}
} finally {
redisService.unlock(lockKey);
@ -244,235 +239,229 @@ public class TaskServiceImpl implements TaskService {
return true;
}
/**
* 获取任务列表V2（优化版）
*/
@Override
public List<TaskDTO> getTaskListV2(AppExtCommand cmd) {
List<TaskDTO> resultList = new ArrayList<>();
String date = DateUtil.format(new Date(), "yyyy-MM-dd");
Long userId = cmd.getReqUserId();
List<TaskDTO> resultList = new ArrayList<>();
String date = DateUtil.format(new Date(), "yyyy-MM-dd");
Long userId = cmd.getReqUserId();
// 1. 查询所有任务配置
List<TaskConfig> taskConfigs = taskConfigDao.selectList(
new LambdaQueryWrapper<TaskConfig>()
.orderByAsc(TaskConfig::getSortOrder));
// 1. 查询所有任务配置
List<TaskConfig> taskConfigs = taskConfigDao.selectList(
new LambdaQueryWrapper<TaskConfig>().orderByAsc(TaskConfig::getSortOrder));
if (CollectionUtils.isEmpty(taskConfigs)) {
return resultList;
}
// 2. 查询用户已有的任务进度
List<UserTaskProgress> existingProgressList = userTaskProgressDao.selectList(
new LambdaQueryWrapper<UserTaskProgress>()
.eq(UserTaskProgress::getUserId, userId)
.and(wrapper -> wrapper
.eq(UserTaskProgress::getTaskType, 2) // 成长任务
.or()
.eq(UserTaskProgress::getDayString, date) // 今日每日任务
));
// 3. 构建已有进度的Map
Map<String, UserTaskProgress> existingProgressMap = buildProgressMap(existingProgressList, date);
// 4. 检查并创建缺失的任务进度
List<UserTaskProgress> newProgressList = createMissingProgress(
userId, taskConfigs, date, existingProgressMap);
// 5. 批量插入新创建的任务进度
if (!newProgressList.isEmpty()) {
userTaskProgressDao.insertBatchSomeColumn(newProgressList);
}
// 6. 查询奖励详情
Set<Long> rewardIds = taskConfigs.stream()
.map(TaskConfig::getRewardId)
.collect(Collectors.toSet());
Map<Long, ActivityPropsGroup> activityMap = propsActivityCnfClient
.mapActivityPropsGroup(cmd.getReqSysOrigin().getOrigin(), rewardIds)
.getBody();
// 7. 组装返回结果
for (TaskConfig taskConfig : taskConfigs) {
String key = buildProgressKey(taskConfig.getTaskId(), taskConfig.getTaskType(), date);
UserTaskProgress progress = existingProgressMap.get(key);
if (progress == null) {
continue;
}
ActivityPropsGroup activity = activityMap.get(progress.getRewardId());
if (activity != null && !activity.getActivityRewardProps().isEmpty()) {
TaskDTO taskDTO = buildTaskDTO(taskConfig, progress, activity, userId);
resultList.add(taskDTO);
}
}
if (CollectionUtils.isEmpty(taskConfigs)) {
return resultList;
}
// 2. 查询用户已有的任务进度
List<UserTaskProgress> existingProgressList = userTaskProgressDao.selectList(
new LambdaQueryWrapper<UserTaskProgress>()
.eq(UserTaskProgress::getUserId, userId)
.and(wrapper -> wrapper
.eq(UserTaskProgress::getTaskType, 2) // 成长任务
.or()
.eq(UserTaskProgress::getDayString, date) // 今日每日任务
));
// 3. 构建已有进度的Map，key为 taskId_dayString(每日任务) 或 taskId(成长任务)
Map<String, UserTaskProgress> existingProgressMap = new HashMap<>();
for (UserTaskProgress progress : existingProgressList) {
String key = progress.getTaskType() == 1
? progress.getTaskId() + "_" + progress.getDayString()
: String.valueOf(progress.getTaskId());
existingProgressMap.put(key, progress);
}
// 4. 检查并创建缺失的任务进度
List<UserTaskProgress> newProgressList = new ArrayList<>();
for (TaskConfig taskConfig : taskConfigs) {
String key;
UserTaskProgress progress;
if (taskConfig.getTaskType() == 1) {
// 每日任务：需要判断当天是否有记录
key = taskConfig.getTaskId() + "_" + date;
progress = existingProgressMap.get(key);
if (progress == null) {
// 创建今日的每日任务进度
progress = new UserTaskProgress();
progress.setId(IdWorkerUtils.getId());
progress.setUserId(userId);
progress.setTaskId(taskConfig.getTaskId());
progress.setIsRewardCollected(0);
progress.setRewardId(taskConfig.getRewardId());
progress.setTaskType(taskConfig.getTaskType());
progress.setTaskStatus(0);
progress.setDayString(date);
progress.setCreateTimestamp(TimestampUtils.now());
newProgressList.add(progress);
existingProgressMap.put(key, progress);
}
} else if (taskConfig.getTaskType() == 2) {
// 成长任务：只需判断是否有记录
key = String.valueOf(taskConfig.getTaskId());
progress = existingProgressMap.get(key);
if (progress == null) {
// 创建成长任务进度
progress = new UserTaskProgress();
progress.setId(IdWorkerUtils.getId());
progress.setUserId(userId);
progress.setTaskId(taskConfig.getTaskId());
progress.setIsRewardCollected(0);
progress.setRewardId(taskConfig.getRewardId());
progress.setTaskType(taskConfig.getTaskType());
progress.setTaskStatus(0);
progress.setCreateTimestamp(TimestampUtils.now());
newProgressList.add(progress);
existingProgressMap.put(key, progress);
}
}
}
// 5. 批量插入新创建的任务进度
if (!newProgressList.isEmpty()) {
userTaskProgressDao.insertBatchSomeColumn(newProgressList);
}
// 6. 查询奖励详情
Set<Long> rewardIds = taskConfigs.stream()
.map(TaskConfig::getRewardId)
.collect(Collectors.toSet());
Map<Long, ActivityPropsGroup> activityMap = propsActivityCnfClient
.mapActivityPropsGroup(cmd.getReqSysOrigin().getOrigin(), rewardIds)
.getBody();
// 7. 组装返回结果
for (TaskConfig taskConfig : taskConfigs) {
String key = taskConfig.getTaskType() == 1
? taskConfig.getTaskId() + "_" + date
: String.valueOf(taskConfig.getTaskId());
UserTaskProgress progress = existingProgressMap.get(key);
if (progress == null) {
continue; // 理论上不会发生
}
ActivityPropsGroup activity = activityMap.get(progress.getRewardId());
if (activity != null && !activity.getActivityRewardProps().isEmpty()) {
TaskDTO build = TaskDTO.builder()
.taskType(progress.getTaskType())
.taskId(progress.getTaskId())
.taskDesc(taskConfig.getTaskDesc())
.jumpPage(taskConfig.getJumpPage())
.taskStatus(progress.getTaskStatus())
.isRewardCollected(progress.getIsRewardCollected())
.taskIcon(taskConfig.getTaskIcon())
.conditionType(getConditionType(activity.getActivityRewardProps()))
.conditionValue(getConditionValue(activity.getActivityRewardProps()))
.targetValue(taskConfig.getTargetValue())
.quantity(activity.getActivityRewardProps().get(0).getQuantity())
.build();
// 特殊处理任务ID为1的情况
if (progress.getTaskId() == 1) {
String redisKey = "mic:heartbeat:" + userId;
String inc = redisService.getString(redisKey);
build.setCompletedValue(inc == null ? "0" : inc);
} else {
build.setCompletedValue(progress.getTaskStatus().toString());
}
resultList.add(build);
}
}
return resultList;
}
private String getConditionType(List<ActivityRewardProps> activityRewardProps) {
StringBuilder conditionType = new StringBuilder();
for (ActivityRewardProps activityRewardProp : activityRewardProps) {
conditionType.append(activityRewardProp.getType());
conditionType.append("-");
}
conditionType.deleteCharAt(conditionType.length() - 1);
return conditionType.toString();
}
private String getConditionValue(List<ActivityRewardProps> activityRewardProps) {
StringBuilder conditionValue = new StringBuilder();
for (ActivityRewardProps activityRewardProp : activityRewardProps) {
conditionValue.append(activityRewardProp.getQuantity());
conditionValue.append("-");
}
conditionValue.deleteCharAt(conditionValue.length() - 1);
return conditionValue.toString();
}
// ==================== 私有辅助方法 ====================
/**
* 创建每日任务
*
* @param userId 用户 ID
* 构建进度Map的Key
* 每日任务：taskId_date
* 成长任务：taskId
*/
private List<UserTaskProgress> createDailyTasksIfNotExists(Long userId, List<TaskConfig> list, String date) {
// 这期判断是否需要创建每日任务
private String buildProgressKey(Long taskId, Integer taskType, String date) {
return taskType == 1 ? taskId + "_" + date : String.valueOf(taskId);
}
/**
* 构建已有进度的Map
*/
private Map<String, UserTaskProgress> buildProgressMap(
List<UserTaskProgress> progressList, String date) {
Map<String, UserTaskProgress> progressMap = new HashMap<>();
for (UserTaskProgress progress : progressList) {
String key = buildProgressKey(
progress.getTaskId(),
progress.getTaskType(),
progress.getDayString() != null ? progress.getDayString() : date);
progressMap.put(key, progress);
}
return progressMap;
}
/**
* 创建缺失的任务进度
*/
private List<UserTaskProgress> createMissingProgress(
Long userId,
List<TaskConfig> taskConfigs,
String date,
Map<String, UserTaskProgress> existingProgressMap) {
List<UserTaskProgress> newProgressList = new ArrayList<>();
for (TaskConfig taskConfig : taskConfigs) {
String key = buildProgressKey(taskConfig.getTaskId(), taskConfig.getTaskType(), date);
if (existingProgressMap.containsKey(key)) {
continue; // 已存在，跳过
}
UserTaskProgress progress = createNewProgress(userId, taskConfig, date);
newProgressList.add(progress);
existingProgressMap.put(key, progress);
}
return newProgressList;
}
/**
* 创建新的任务进度对象
*/
private UserTaskProgress createNewProgress(Long userId, TaskConfig taskConfig, String date) {
UserTaskProgress progress = new UserTaskProgress();
progress.setId(IdWorkerUtils.getId());
progress.setUserId(userId);
progress.setTaskId(taskConfig.getTaskId());
progress.setIsRewardCollected(0);
progress.setRewardId(taskConfig.getRewardId());
progress.setTaskType(taskConfig.getTaskType());
progress.setTaskStatus(0);
progress.setCreateTimestamp(TimestampUtils.now());
// 每日任务需要设置日期
if (taskConfig.getTaskType() == 1) {
progress.setDayString(date);
}
return progress;
}
/**
* 构建TaskDTO对象
*/
private TaskDTO buildTaskDTO(
TaskConfig taskConfig,
UserTaskProgress progress,
ActivityPropsGroup activity,
Long userId) {
TaskDTO taskDTO = TaskDTO.builder()
.taskType(progress.getTaskType())
.taskId(progress.getTaskId())
.taskDesc(taskConfig.getTaskDesc())
.jumpPage(taskConfig.getJumpPage())
.taskStatus(progress.getTaskStatus())
.isRewardCollected(progress.getIsRewardCollected())
.taskIcon(taskConfig.getTaskIcon())
.conditionType(extractConditionType(activity.getActivityRewardProps()))
.conditionValue(extractConditionValue(activity.getActivityRewardProps()))
.targetValue(taskConfig.getTargetValue())
.quantity(activity.getActivityRewardProps().get(0).getQuantity())
.build();
// 特殊处理任务ID为1的情况（心跳任务）
if (progress.getTaskId() == 1) {
String redisKey = "mic:heartbeat:" + userId;
String inc = redisService.getString(redisKey);
taskDTO.setCompletedValue(inc == null ? "0" : String.valueOf(Math.min(Integer.parseInt(inc), 10)));
} else {
taskDTO.setCompletedValue(progress.getTaskStatus().toString());
}
return taskDTO;
}
/**
* 提取条件类型
*/
private String extractConditionType(List<ActivityRewardProps> activityRewardProps) {
return activityRewardProps.stream()
.map(ActivityRewardProps::getType)
.collect(Collectors.joining("-"));
}
/**
* 提取条件值
*/
private String extractConditionValue(List<ActivityRewardProps> activityRewardProps) {
return activityRewardProps.stream()
.map(prop -> String.valueOf(prop.getQuantity()))
.collect(Collectors.joining("-"));
}
/**
* 创建每日任务（如果不存在）
*/
private List<UserTaskProgress> createDailyTasksIfNotExists(
Long userId, List<TaskConfig> list, String date) {
// 查询是否有这一天的任务
LambdaQueryWrapper<UserTaskProgress> queryWrapper = new LambdaQueryWrapper<>();
//查询是否有这一天的任务
queryWrapper.eq(UserTaskProgress::getDayString, date);
queryWrapper.eq(UserTaskProgress::getUserId, userId);
queryWrapper.eq(UserTaskProgress::getDayString, date)
.eq(UserTaskProgress::getUserId, userId);
List<UserTaskProgress> userTaskList = userTaskProgressDao.selectList(queryWrapper);
//为空的时候新增任务
List<UserTaskProgress> userTaskProgressList = new ArrayList<>();
if (userTaskList.isEmpty()) {
//创建一个list 批量新增
for (TaskConfig taskConfig : list.stream().filter(task -> task.getTaskType() == 1).toList()) {
UserTaskProgress userTaskProgress = new UserTaskProgress();
userTaskProgress.setId(IdWorkerUtils.getId());
userTaskProgress.setUserId(userId);
userTaskProgress.setTaskId(taskConfig.getTaskId());
userTaskProgress.setIsRewardCollected(0);
userTaskProgress.setRewardId(taskConfig.getRewardId());
userTaskProgress.setTaskType(taskConfig.getTaskType());
userTaskProgress.setTaskStatus(0);
userTaskProgress.setDayString(date);
userTaskProgress.setCreateTimestamp(TimestampUtils.now());
userTaskProgressList.add(userTaskProgress);
}
userTaskProgressDao.insertBatchSomeColumn(userTaskProgressList);
} else {
// 已存在，直接返回
if (!userTaskList.isEmpty()) {
return userTaskList;
}
// 创建新的每日任务
List<UserTaskProgress> userTaskProgressList = new ArrayList<>();
for (TaskConfig taskConfig : list) {
if (taskConfig.getTaskType() != 1) {
continue; // 只处理每日任务
}
UserTaskProgress userTaskProgress = createNewProgress(userId, taskConfig, date);
userTaskProgressList.add(userTaskProgress);
}
userTaskProgressDao.insertBatchSomeColumn(userTaskProgressList);
return userTaskProgressList;
}
private List<UserTaskProgress> createTasksIfNotExists(Long userId, List<TaskConfig> taskConfigs) {
// 这期判断是否需要创建每日任务
LambdaQueryWrapper<UserTaskProgress> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(UserTaskProgress::getUserId, userId);
//成长任务
queryWrapper.eq(UserTaskProgress::getTaskType, 2);
List<UserTaskProgress> userTaskList = userTaskProgressDao.selectList(queryWrapper);
//为空的时候新增任务
List<UserTaskProgress> userTaskProgressList = new ArrayList<>();
if (userTaskList.isEmpty()) {
taskConfigs.stream().filter(task -> task.getTaskType() == 2).forEach(taskConfig -> {
UserTaskProgress userTaskProgress = new UserTaskProgress();
userTaskProgress.setId(IdWorkerUtils.getId());
userTaskProgress.setUserId(userId);
userTaskProgress.setTaskId(taskConfig.getTaskId());
userTaskProgress.setIsRewardCollected(0);
userTaskProgress.setRewardId(taskConfig.getRewardId());
userTaskProgress.setTaskType(taskConfig.getTaskType());
userTaskProgress.setTaskStatus(0);
userTaskProgress.setCreateTimestamp(TimestampUtils.now());
userTaskProgressList.add(userTaskProgress);
});
userTaskProgressDao.insertBatchSomeColumn(userTaskProgressList);
return userTaskProgressList;
}
return userTaskList;
}
}

19
rc-service/rc-service-other/other-application/src/main/java/com/red/circle/other/app/util/DateTimeAsiaRiyadhUtils.java Normal file
View File

@ -0,0 +1,19 @@
package com.red.circle.other.app.util;
import com.red.circle.tool.core.date.ZonedDateTimeAsiaRiyadhUtils;
import java.time.ZonedDateTime;
public class DateTimeAsiaRiyadhUtils {
/**
* 获取当前时间到凌晨的秒数
* @return 秒数
*/
public static long getSecondsUntilMidnight() {
ZonedDateTime now = ZonedDateTimeAsiaRiyadhUtils.now();
ZonedDateTime midnight = now.toLocalDate().plusDays(1).atStartOfDay(now.getZone());
return java.time.Duration.between(now, midnight).getSeconds();
}
}

46
rc-service/rc-service-other/other-client/src/main/java/com/red/circle/other/app/service/task/TaskService.java
View File

@ -5,19 +5,55 @@ import com.red.circle.other.app.dto.task.TaskDTO;
import java.util.List;
/**
* 任务服务接口
*/
public interface TaskService {
/**
* 获取任务列表
* @param cmd 命令对象
* @return 任务列表
*/
List<TaskDTO> getTaskList(AppExtCommand cmd);
/**
* 获取任务状态（是否有完成但未领取的任务）
* @param userId 用户ID
* @return 是否有未领取奖励
*/
Boolean getTaskStatus(Long userId);
void updateTaskStatus(Integer status ,Long userId,Long TaskId,String date);
void updateTaskStatus(Integer status ,Long userId,Long TaskId);
/**
* 更新任务状态
* @param status 任务状态
* @param userId 用户ID
* @param taskId 任务ID
* @param date 日期（可选，每日任务需要传入）
*/
void updateTaskStatus(Integer status, Long userId, Long taskId, String date);
Boolean checkTaskStatus(Long userId,Long TaskId,String date);
Boolean checkTaskStatus(Long userId,Long TaskId);
/**
* 检查任务状态
* @param userId 用户ID
* @param taskId 任务ID
* @param date 日期（可选，每日任务需要传入）
* @return true=未完成，false=已完成
*/
Boolean checkTaskStatus(Long userId, Long taskId, String date);
/**
* 领取任务奖励
* @param cmd 命令对象
* @param taskId 任务ID
* @return 操作结果
*/
Boolean claimReward(AppExtCommand cmd, Long taskId);
/**
* 获取任务列表V2（优化版）
* @param cmd 命令对象
* @return 任务列表
*/
List<TaskDTO> getTaskListV2(AppExtCommand cmd);
}