Merge remote-tracking branch 'origin/point_dev' into point_dev

nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/TOrderServiceImpl.java

@@ -23,6 +23,7 @@ import com.ylx.massage.enums.OrderStatusEnum;
 import com.ylx.massage.mapper.TOrderMapper;
 import com.ylx.massage.service.*;
 import com.ylx.massage.utils.*;
+import com.ylx.point.service.IPointUserActivityTaskCompletionService;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.compress.utils.Lists;
 import org.springframework.stereotype.Service;
@@ -97,6 +98,9 @@ public class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> impleme
     @Resource
     private OrderNotificationService orderNotificationService;
 
+    @Resource
+    private IPointUserActivityTaskCompletionService pointUserActivityTaskCompletionService;
+
     @Resource
     private OrderAllocationLogService allocationLogService;
 
@@ -881,6 +885,14 @@ public class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> impleme
 
         // 添加订单完成消息通知（用户侧）
         orderNotificationService.sendCompletedNotification(orderNew);
+        
+        // 完成积分任务（按照新手活动、每日活动、每月活动的优先级顺序）
+        try {
+            pointUserActivityTaskCompletionService.completeOrderTaskByPriority(orderNew.getcOpenId());
+        } catch (Exception e) {
+            log.error("完成积分任务失败 - 订单号：{}, 错误信息：{}", orderNew.getOrderNo(), e.getMessage(), e);
+        }
+        
         return true;
     }
 

nightFragrance-massage/src/main/java/com/ylx/point/service/IPointUserActivityTaskCompletionService.java

@@ -36,4 +36,16 @@ public interface IPointUserActivityTaskCompletionService extends IService<PointU
     int getUserTaskTotalCount(String openId, Long activityId, Long taskId, Integer taskType);
 
     void executeTask(Long taskId);
+
+    /**
+     * 按照活动类型优先级（新手活动、每日活动、每月活动）完成订单任务并添加积分
+     * @param openId 用户openId
+     */
+    void completeOrderTaskByPriority(String openId);
+
+    /**
+     * 按照活动类型优先级（新手活动、每日活动、每月活动）完成充值任务并添加积分
+     * @param openId 用户openId
+     */
+    void completeRechargeTaskByPriority(String openId);
 }

nightFragrance-massage/src/main/java/com/ylx/point/service/impl/PointUserActivityTaskCompletionServiceImpl.java

@@ -1,5 +1,6 @@
 package com.ylx.point.service.impl;
 
+import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import cn.hutool.core.util.StrUtil;
@@ -25,13 +26,16 @@ import com.ylx.point.service.IPointAccountService;
 import com.ylx.point.service.IPointActivityService;
 import com.ylx.point.service.IPointActivityTaskService;
 import com.ylx.point.service.IPointUserActivityTaskCompletionService;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
 import java.time.LocalDate;
+import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * 用户活动任务完成Service业务层处理
@@ -39,6 +43,7 @@ import java.util.List;
  * @author wzj
  * @date 2026-03-25
  */
+@Slf4j
 @Service
 public class PointUserActivityTaskCompletionServiceImpl extends ServiceImpl<PointUserActivityTaskCompletionMapper, PointUserActivityTaskCompletion> implements IPointUserActivityTaskCompletionService {
 
@@ -301,4 +306,321 @@ public class PointUserActivityTaskCompletionServiceImpl extends ServiceImpl<Poin
         return loginUser;
     }
 
+    /**
+     * 通用任务完成方法（内部使用）
+     * @param openId 用户openId
+     * @param taskTypeEnum 任务类型枚举
+     * @param activityNameEnum 活动名称枚举
+     * @param countSupplier 查询已完成次数的函数
+     */
+    private void completeTaskByPriorityInternal(String openId,
+                                           PointActivityTaskTypeEnum taskTypeEnum,
+                                           ActivityNameEnum activityNameEnum,
+                                           java.util.function.Function<Date, Integer> countSupplier) {
+        // 活动类型优先级：新手活动、每日活动、每月活动
+        List<Integer> priorityTypes = Arrays.asList(
+            PointActivityTypeEnum.NEW_USER_ACTIVITY.getCode(),
+            PointActivityTypeEnum.DAILY_ACTIVITY.getCode(),
+            PointActivityTypeEnum.MONTHLY_ACTIVITY.getCode()
+        );
+
+        // 按优先级遍历活动类型
+        for (Integer activityType : priorityTypes) {
+            try {
+                // 查询该活动类型下所有进行中的任务
+                List<PointActivityTask> taskList = pointActivityTaskService.list(
+                    Wrappers.lambdaQuery(PointActivityTask.class)
+                        .eq(PointActivityTask::getTaskName, activityNameEnum.getInfo())
+                        .eq(PointActivityTask::getStatus, 0)
+                        .eq(PointActivityTask::getIsDeleted, 0)
+                );
+
+                // 过滤出属于该活动类型的任务
+                taskList = taskList.stream()
+                    .filter(task -> {
+                        PointActivity activity = pointActivityService.getById(task.getActivityId());
+                        return activity != null
+                            && activity.getActivityType().equals(activityType)
+                            && activity.getStatus().equals(PointActivityStatusEnum.IN_PROGRESS.getCode());
+                    })
+                    .collect(Collectors.toList());
+
+                if (CollectionUtil.isEmpty(taskList)) {
+                    continue;
+                }
+
+                // 对每个任务按优先级顺序执行
+                for (PointActivityTask task : taskList) {
+                    try {
+                        // 获取任务信息
+                        PointActivity activity = pointActivityService.getById(task.getActivityId());
+
+                        // 获取触发阈值（目标次数）
+                        int targetCount = Integer.parseInt(task.getTriggerValue());
+
+                        // 获取限制类型值（每日/每月/一次性）
+                        String frequencyLimitValue = task.getFrequencyLimitValue();
+
+                        // 计算查询业务数据的时间起点
+                        Date queryTime = getQueryStartTime(activity.getIsPermanent(), activity.getStartTime(), activity.getActivityType());
+
+                        // 查询用户已完成次数
+                        int completedCount = countSupplier.apply(queryTime);
+
+                        // 判断是否达到目标次数
+                        if (completedCount >= targetCount) {
+                            // 查询是否已经完成过该任务
+                            PointUserActivityTaskCompletion existingRecord = this.getOne(
+                                new LambdaQueryWrapper<PointUserActivityTaskCompletion>()
+                                    .eq(PointUserActivityTaskCompletion::getOpenId, openId)
+                                    .eq(PointUserActivityTaskCompletion::getTaskId, task.getId())
+                                    .eq(PointUserActivityTaskCompletion::getActivityId, activity.getId())
+                                    .eq(PointUserActivityTaskCompletion::getTaskType, taskTypeEnum.getCode())
+                            );
+
+                            // 检查是否已经达到目标次数（防刷）
+                            if (existingRecord != null && existingRecord.getCompletedCount() >= targetCount) {
+                                // 已经完成过，继续尝试下一个任务
+                                continue;
+                            }
+
+                            // 更新任务完成记录
+                            completeTask(openId, activity.getId(), task.getId(), taskTypeEnum.getCode());
+
+                            // 发放积分
+                            pointAccountService.addPoints(
+                                openId,
+                                task.getRewardPoints().intValue(),
+                                activityNameEnum.getInfo(),
+                                null,
+                                activity.getId(),
+                                task.getId(),
+                                taskTypeEnum.getCode()
+                            );
+
+                            // 成功完成一个任务后，跳出循环（只完成优先级最高的一个任务）
+                            return;
+                        }
+                    } catch (ServiceException e) {
+                        // 如果任务已完成或不符合条件，继续尝试下一个任务
+                        if (!e.getMessage().contains("今日任务已完成")
+                            && !e.getMessage().contains("任务奖励已领取")) {
+                            // 其他异常则抛出
+                            throw e;
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                log.error("完成{}任务失败 - 活动类型：{}, 错误信息：{}", activityNameEnum.getInfo(), activityType, e.getMessage(), e);
+                // 继续尝试下一个优先级的活动类型
+            }
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void completeOrderTaskByPriority(String openId) {
+        // 活动类型优先级：新手活动、每日活动、每月活动
+        List<Integer> priorityTypes = Arrays.asList(
+            PointActivityTypeEnum.NEW_USER_ACTIVITY.getCode(),
+            PointActivityTypeEnum.DAILY_ACTIVITY.getCode(),
+            PointActivityTypeEnum.MONTHLY_ACTIVITY.getCode()
+        );
+
+        // 按优先级遍历活动类型
+        for (Integer activityType : priorityTypes) {
+            try {
+                // 查询该活动类型下所有进行中的"完成订单"任务
+                List<PointActivityTask> taskList = pointActivityTaskService.list(
+                    Wrappers.lambdaQuery(PointActivityTask.class)
+                        .eq(PointActivityTask::getTaskName, ActivityNameEnum.COMPLETE_ORDER.getInfo())
+                        .eq(PointActivityTask::getStatus, 0)
+                        .eq(PointActivityTask::getIsDeleted, 0)
+                );
+
+                // 过滤出属于该活动类型的任务
+                taskList = taskList.stream()
+                    .filter(task -> {
+                        PointActivity activity = pointActivityService.getById(task.getActivityId());
+                        return activity != null
+                            && activity.getActivityType().equals(activityType)
+                            && activity.getStatus().equals(PointActivityStatusEnum.IN_PROGRESS.getCode());
+                    })
+                    .collect(Collectors.toList());
+
+                if (CollectionUtil.isEmpty(taskList)) {
+                    continue;
+                }
+
+                // 对每个任务按优先级顺序执行
+                for (PointActivityTask task : taskList) {
+                    try {
+                        // 获取任务信息
+                        PointActivity activity = pointActivityService.getById(task.getActivityId());
+
+                        // 获取触发阈值（目标次数）
+                        int targetCount = Integer.parseInt(task.getTriggerValue());
+
+                        // 获取限制类型值（每日/每月/一次性）
+                        String frequencyLimitValue = task.getFrequencyLimitValue();
+
+                        // 计算查询业务数据的时间起点
+                        Date queryTime = getQueryStartTime(activity.getIsPermanent(), activity.getStartTime(), activity.getActivityType());
+
+                        // 查询用户已完成订单数
+                        int orderCount = orderService.countCompletedOrders(openId, queryTime);
+
+                        // 判断是否达到目标次数
+                        if (orderCount >= targetCount) {
+                            // 查询是否已经完成过该任务
+                            PointUserActivityTaskCompletion existingRecord = this.getOne(
+                                new LambdaQueryWrapper<PointUserActivityTaskCompletion>()
+                                    .eq(PointUserActivityTaskCompletion::getOpenId, openId)
+                                    .eq(PointUserActivityTaskCompletion::getTaskId, task.getId())
+                                    .eq(PointUserActivityTaskCompletion::getActivityId, activity.getId())
+                                    .eq(PointUserActivityTaskCompletion::getTaskType, PointActivityTaskTypeEnum.COMPLETE_ORDER.getCode())
+                            );
+
+                            // 检查是否已经达到目标次数（防刷）
+                            if (existingRecord != null && existingRecord.getCompletedCount() >= targetCount) {
+                                // 已经完成过，继续尝试下一个任务
+                                continue;
+                            }
+
+                            // 更新任务完成记录
+                            completeTask(openId, activity.getId(), task.getId(), PointActivityTaskTypeEnum.COMPLETE_ORDER.getCode());
+
+                            // 发放积分
+                            pointAccountService.addPoints(
+                                openId,
+                                task.getRewardPoints().intValue(),
+                                ActivityNameEnum.COMPLETE_ORDER.getInfo(),
+                                null,
+                                activity.getId(),
+                                task.getId(),
+                                PointActivityTaskTypeEnum.COMPLETE_ORDER.getCode()
+                            );
+
+                            // 成功完成一个任务后，跳出循环（只完成优先级最高的一个任务）
+                            return;
+                        }
+                    } catch (ServiceException e) {
+                        // 如果任务已完成或不符合条件，继续尝试下一个任务
+                        if (!e.getMessage().contains("今日任务已完成")
+                            && !e.getMessage().contains("任务奖励已领取")) {
+                            // 其他异常则抛出
+                            throw e;
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                log.error("完成订单任务失败 - 活动类型：{}, 错误信息：{}", activityType, e.getMessage(), e);
+                // 继续尝试下一个优先级的活动类型
+            }
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void completeRechargeTaskByPriority(String openId) {
+        // 活动类型优先级：新手活动、每日活动、每月活动
+        List<Integer> priorityTypes = Arrays.asList(
+            PointActivityTypeEnum.NEW_USER_ACTIVITY.getCode(),
+            PointActivityTypeEnum.DAILY_ACTIVITY.getCode(),
+            PointActivityTypeEnum.MONTHLY_ACTIVITY.getCode()
+        );
+
+        // 按优先级遍历活动类型
+        for (Integer activityType : priorityTypes) {
+            try {
+                // 查询该活动类型下所有进行中的"充值任务"
+                List<PointActivityTask> taskList = pointActivityTaskService.list(
+                    Wrappers.lambdaQuery(PointActivityTask.class)
+                        .eq(PointActivityTask::getTaskName, ActivityNameEnum.RECHARGE_TASK.getInfo())
+                        .eq(PointActivityTask::getStatus, 0)
+                        .eq(PointActivityTask::getIsDeleted, 0)
+                );
+
+                // 过滤出属于该活动类型的任务
+                taskList = taskList.stream()
+                    .filter(task -> {
+                        PointActivity activity = pointActivityService.getById(task.getActivityId());
+                        return activity != null
+                            && activity.getActivityType().equals(activityType)
+                            && activity.getStatus().equals(PointActivityStatusEnum.IN_PROGRESS.getCode());
+                    })
+                    .collect(Collectors.toList());
+
+                if (CollectionUtil.isEmpty(taskList)) {
+                    continue;
+                }
+
+                // 对每个任务按优先级顺序执行
+                for (PointActivityTask task : taskList) {
+                    try {
+                        // 获取任务信息
+                        PointActivity activity = pointActivityService.getById(task.getActivityId());
+
+                        // 获取触发阈值（目标次数）
+                        int targetCount = Integer.parseInt(task.getTriggerValue());
+
+                        // 获取限制类型值（每日/每月/一次性）
+                        String frequencyLimitValue = task.getFrequencyLimitValue();
+
+                        // 计算查询业务数据的时间起点
+                        Date queryTime = getQueryStartTime(activity.getIsPermanent(), activity.getStartTime(), activity.getActivityType());
+
+                        // 查询用户已完成充值数
+                        int rechargeCount = rechargeService.countSuccessRecharges(openId, queryTime);
+
+                        // 判断是否达到目标次数
+                        if (rechargeCount >= targetCount) {
+                            // 查询是否已经完成过该任务
+                            PointUserActivityTaskCompletion existingRecord = this.getOne(
+                                new LambdaQueryWrapper<PointUserActivityTaskCompletion>()
+                                    .eq(PointUserActivityTaskCompletion::getOpenId, openId)
+                                    .eq(PointUserActivityTaskCompletion::getTaskId, task.getId())
+                                    .eq(PointUserActivityTaskCompletion::getActivityId, activity.getId())
+                                    .eq(PointUserActivityTaskCompletion::getTaskType, PointActivityTaskTypeEnum.RECHARGE_TASK.getCode())
+                            );
+
+                            // 检查是否已经达到目标次数（防刷）
+                            if (existingRecord != null && existingRecord.getCompletedCount() >= targetCount) {
+                                // 已经完成过，继续尝试下一个任务
+                                continue;
+                            }
+
+                            // 更新任务完成记录
+                            completeTask(openId, activity.getId(), task.getId(), PointActivityTaskTypeEnum.RECHARGE_TASK.getCode());
+
+                            // 发放积分
+                            pointAccountService.addPoints(
+                                openId,
+                                task.getRewardPoints().intValue(),
+                                ActivityNameEnum.RECHARGE_TASK.getInfo(),
+                                null,
+                                activity.getId(),
+                                task.getId(),
+                                PointActivityTaskTypeEnum.RECHARGE_TASK.getCode()
+                            );
+
+                            // 成功完成一个任务后，跳出循环（只完成优先级最高的一个任务）
+                            return;
+                        }
+                    } catch (ServiceException e) {
+                        // 如果任务已完成或不符合条件，继续尝试下一个任务
+                        if (!e.getMessage().contains("今日任务已完成")
+                            && !e.getMessage().contains("任务奖励已领取")) {
+                            // 其他异常则抛出
+                            throw e;
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                log.error("完成充值任务失败 - 活动类型：{}, 错误信息：{}", activityType, e.getMessage(), e);
+                // 继续尝试下一个优先级的活动类型
+            }
+        }
+    }
+
 }