JDWA Green-U 积分系统模块

@Data
@TableName("jdwa_user_points")
public class JDWAUserPoints {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private String pointsType;
    private Integer pointsBalance;
    private Integer totalIncome;
    private Integer totalExpense;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_points_record")
public class JDWAPointsRecord {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Integer points;
    private String pointsType;
    private String operationType;
    private String businessType;
    private String businessId;
    private String description;
    private Integer beforeBalance;
    private Integer afterBalance;
    private LocalDateTime expireTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_points_task")
public class JDWAPointsTask {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String taskCode;
    private String taskName;
    private String taskType;
    private String pointsType;
    private Integer pointsAmount;
    private String taskCondition;
    private String taskIcon;
    private String taskDesc;
    private Integer status;
    private LocalDateTime startTime;
    private LocalDateTime endTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_user_task")
public class JDWAUserTask {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long taskId;
    private String taskCode;
    private Integer progress;
    private Integer targetValue;
    private Integer status;  // 0-未完成，1-已完成，2-已领取奖励
    private LocalDateTime completeTime;
    private LocalDateTime rewardTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_points_goods")
public class JDWAPointsGoods {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String goodsCode;
    private String goodsName;
    private String goodsType;  // VIRTUAL-虚拟商品，PHYSICAL-实物商品
    private Integer pointsPrice;
    private String pointsType;
    private String goodsImg;
    private String goodsDesc;
    private Integer stock;
    private Integer exchangeLimit;  // 单用户兑换限制
    private Integer status;  // 0-下架，1-上架
    private LocalDateTime startTime;
    private LocalDateTime endTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@RestController
@RequestMapping("/api/points")
public class JDWAPointsController extends JDWABaseController {

    @Autowired
    private JDWAPointsService pointsService;
    
    @Autowired
    private JDWAPointsTaskService taskService;
    
    @Autowired
    private JDWAPointsGoodsService goodsService;
    
    /**
     * 获取用户积分概览
     */
    @GetMapping("/overview")
    public JDWAResult<Object> getPointsOverview() {
        Long userId = getCurrentUserId();
        Map<String, Object> overview = pointsService.getPointsOverview(userId);
        
        return JDWAResult.success("获取成功", overview);
    }
    
    /**
     * 获取积分明细列表
     */
    @GetMapping("/records")
    public JDWAResult<Object> getPointsRecords(
            @RequestParam(required = false) String pointsType,
            @RequestParam(required = false) String operationType,
            @RequestParam(required = false) String startDate,
            @RequestParam(required = false) String endDate,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Long userId = getCurrentUserId();
        Page<JDWAPointsRecord> page = pointsService.getPointsRecords(
                userId, pointsType, operationType, startDate, endDate, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", page);
    }
    
    /**
     * 获取任务列表
     */
    @GetMapping("/tasks")
    public JDWAResult<Object> getPointsTasks(
            @RequestParam(required = false) String taskType) {
        
        Long userId = getCurrentUserId();
        List<Map<String, Object>> tasks = taskService.getUserTasks(userId, taskType);
        
        return JDWAResult.success("获取成功", tasks);
    }
    
    /**
     * 完成任务
     */
    @PostMapping("/task/complete")
    public JDWAResult<Object> completeTask(@RequestBody Map<String, Object> params) {
        Long userId = getCurrentUserId();
        String taskCode = (String) params.get("taskCode");
        
        Map<String, Object> result = taskService.completeTask(userId, taskCode);
        
        return JDWAResult.success("任务完成", result);
    }
    
    /**
     * 领取任务奖励
     */
    @PostMapping("/task/reward")
    public JDWAResult<Object> getTaskReward(@RequestBody Map<String, Object> params) {
        Long userId = getCurrentUserId();
        String taskCode = (String) params.get("taskCode");
        
        Map<String, Object> result = taskService.getTaskReward(userId, taskCode);
        
        return JDWAResult.success("奖励领取成功", result);
    }
    
    /**
     * 获取积分商品列表
     */
    @GetMapping("/goods")
    public JDWAResult<Object> getPointsGoods(
            @RequestParam(required = false) String goodsType,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Page<JDWAPointsGoods> page = goodsService.getPointsGoods(
                goodsType, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", page);
    }
    
    /**
     * 兑换商品
     */
    @PostMapping("/exchange")
    public JDWAResult<Object> exchangeGoods(@RequestBody Map<String, Object> params) {
        Long userId = getCurrentUserId();
        Long goodsId = Long.valueOf(params.get("goodsId").toString());
        Integer quantity = Integer.valueOf(params.get("quantity").toString());
        
        Map<String, Object> result = goodsService.exchangeGoods(userId, goodsId, quantity);
        
        return JDWAResult.success("兑换成功", result);
    }
    
    /**
     * 获取兑换订单列表
     */
    @GetMapping("/orders")
    public JDWAResult<Object> getExchangeOrders(
            @RequestParam(required = false) Integer status,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Long userId = getCurrentUserId();
        Page<JDWAPointsOrder> page = goodsService.getExchangeOrders(
                userId, status, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", page);
    }
}

public interface JDWAPointsService {
    
    /**
     * 增加用户积分
     *
     * @param userId 用户ID
     * @param points 积分数量
     * @param pointsType 积分类型
     * @param businessType 业务类型
     * @param businessId 业务ID
     * @param description 描述
     * @param expireTime 过期时间
     * @return 积分记录
     */
    JDWAPointsRecord addPoints(Long userId, Integer points, String pointsType, 
            String businessType, String businessId, String description, LocalDateTime expireTime);
    
    /**
     * 扣减用户积分
     *
     * @param userId 用户ID
     * @param points 积分数量
     * @param pointsType 积分类型
     * @param businessType 业务类型
     * @param businessId 业务ID
     * @param description 描述
     * @return 积分记录
     */
    JDWAPointsRecord deductPoints(Long userId, Integer points, String pointsType, 
            String businessType, String businessId, String description);
    
    /**
     * 获取用户积分概览
     *
     * @param userId 用户ID
     * @return 积分概览信息
     */
    Map<String, Object> getPointsOverview(Long userId);
    
    /**
     * 获取用户积分余额
     *
     * @param userId 用户ID
     * @param pointsType 积分类型
     * @return 积分余额
     */
    Integer getPointsBalance(Long userId, String pointsType);
    
    /**
     * 获取用户积分记录
     *
     * @param userId 用户ID
     * @param pointsType 积分类型
     * @param operationType 操作类型
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页积分记录
     */
    Page<JDWAPointsRecord> getPointsRecords(Long userId, String pointsType, String operationType, 
            String startDate, String endDate, Integer pageNum, Integer pageSize);
    
    /**
     * 检查并处理过期积分
     *
     * @param executeDate 执行日期
     */
    void processExpiredPoints(LocalDate executeDate);
}

public interface JDWAPointsTaskService {
    
    /**
     * 获取用户任务列表
     *
     * @param userId 用户ID
     * @param taskType 任务类型
     * @return 任务列表
     */
    List<Map<String, Object>> getUserTasks(Long userId, String taskType);
    
    /**
     * 完成任务
     *
     * @param userId 用户ID
     * @param taskCode 任务编码
     * @return 结果
     */
    Map<String, Object> completeTask(Long userId, String taskCode);
    
    /**
     * 领取任务奖励
     *
     * @param userId 用户ID
     * @param taskCode 任务编码
     * @return 结果
     */
    Map<String, Object> getTaskReward(Long userId, String taskCode);
    
    /**
     * 检查任务完成状态
     *
     * @param userId 用户ID
     * @param taskCode 任务编码
     * @return 任务状态
     */
    Integer checkTaskStatus(Long userId, String taskCode);
    
    /**
     * 重置每日任务
     */
    void resetDailyTasks();
}

public interface JDWAPointsGoodsService {
    
    /**
     * 获取积分商品列表
     *
     * @param goodsType 商品类型
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页商品列表
     */
    Page<JDWAPointsGoods> getPointsGoods(String goodsType, Integer pageNum, Integer pageSize);
    
    /**
     * 兑换商品
     *
     * @param userId 用户ID
     * @param goodsId 商品ID
     * @param quantity 数量
     * @return 结果
     */
    Map<String, Object> exchangeGoods(Long userId, Long goodsId, Integer quantity);
    
    /**
     * 获取兑换订单列表
     *
     * @param userId 用户ID
     * @param status 订单状态
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页订单列表
     */
    Page<JDWAPointsOrder> getExchangeOrders(Long userId, Integer status, Integer pageNum, Integer pageSize);
}

@Slf4j
@Service
public class JDWAPointsServiceImpl implements JDWAPointsService {
    
    @Autowired
    private JDWAUserPointsMapper userPointsMapper;
    
    @Autowired
    private JDWAPointsRecordMapper pointsRecordMapper;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public JDWAPointsRecord addPoints(Long userId, Integer points, String pointsType, 
            String businessType, String businessId, String description, LocalDateTime expireTime) {
        
        // 参数校验
        if (points <= 0) {
            throw new JDWAServiceException("积分数量必须大于0");
        }
        
        // 获取或创建用户积分账户
        JDWAUserPoints userPoints = getUserPointsAccount(userId, pointsType);
        
        // 更新用户积分
        Integer beforeBalance = userPoints.getPointsBalance();
        Integer afterBalance = beforeBalance + points;
        
        userPoints.setPointsBalance(afterBalance);
        userPoints.setTotalIncome(userPoints.getTotalIncome() + points);
        userPoints.setUpdateTime(LocalDateTime.now());
        
        userPointsMapper.updateById(userPoints);
        
        // 创建积分记录
        JDWAPointsRecord record = new JDWAPointsRecord();
        record.setUserId(userId);
        record.setPoints(points);
        record.setPointsType(pointsType);
        record.setOperationType("INCOME");
        record.setBusinessType(businessType);
        record.setBusinessId(businessId);
        record.setDescription(description);
        record.setBeforeBalance(beforeBalance);
        record.setAfterBalance(afterBalance);
        record.setExpireTime(expireTime);
        record.setCreateTime(LocalDateTime.now());
        record.setUpdateTime(LocalDateTime.now());
        
        pointsRecordMapper.insert(record);
        
        return record;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public JDWAPointsRecord deductPoints(Long userId, Integer points, String pointsType, 
            String businessType, String businessId, String description) {
        
        // 参数校验
        if (points <= 0) {
            throw new JDWAServiceException("积分数量必须大于0");
        }
        
        // 获取用户积分账户
        JDWAUserPoints userPoints = getUserPointsAccount(userId, pointsType);
        
        // 检查积分余额
        Integer beforeBalance = userPoints.getPointsBalance();
        if (beforeBalance < points) {
            throw new JDWAServiceException("积分余额不足");
        }
        
        // 更新用户积分
        Integer afterBalance = beforeBalance - points;
        
        userPoints.setPointsBalance(afterBalance);
        userPoints.setTotalExpense(userPoints.getTotalExpense() + points);
        userPoints.setUpdateTime(LocalDateTime.now());
        
        userPointsMapper.updateById(userPoints);
        
        // 创建积分记录
        JDWAPointsRecord record = new JDWAPointsRecord();
        record.setUserId(userId);
        record.setPoints(points);
        record.setPointsType(pointsType);
        record.setOperationType("EXPENSE");
        record.setBusinessType(businessType);
        record.setBusinessId(businessId);
        record.setDescription(description);
        record.setBeforeBalance(beforeBalance);
        record.setAfterBalance(afterBalance);
        record.setCreateTime(LocalDateTime.now());
        record.setUpdateTime(LocalDateTime.now());
        
        pointsRecordMapper.insert(record);
        
        return record;
    }
    
    /**
     * 获取用户积分账户，不存在则创建
     */
    private JDWAUserPoints getUserPointsAccount(Long userId, String pointsType) {
        LambdaQueryWrapper<JDWAUserPoints> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(JDWAUserPoints::getUserId, userId)
                .eq(JDWAUserPoints::getPointsType, pointsType);
        
        JDWAUserPoints userPoints = userPointsMapper.selectOne(queryWrapper);
        
        if (userPoints == null) {
            // 创建新账户
            userPoints = new JDWAUserPoints();
            userPoints.setUserId(userId);
            userPoints.setPointsType(pointsType);
            userPoints.setPointsBalance(0);
            userPoints.setTotalIncome(0);
            userPoints.setTotalExpense(0);
            userPoints.setCreateTime(LocalDateTime.now());
            userPoints.setUpdateTime(LocalDateTime.now());
            
            userPointsMapper.insert(userPoints);
        }
        
        return userPoints;
    }
    
    @Override
    @Scheduled(cron = "0 0 1 * * ?") // 每天凌晨1点执行
    public void processExpiredPoints(LocalDate executeDate) {
        if (executeDate == null) {
            executeDate = LocalDate.now();
        }
        
        log.info("开始处理过期积分，执行日期: {}", executeDate);
        
        // 查询今天过期的积分记录
        LocalDateTime startTime = executeDate.atStartOfDay();
        LocalDateTime endTime = executeDate.plusDays(1).atStartOfDay();
        
        List<JDWAPointsRecord> expiredRecords = pointsRecordMapper.selectExpiredPointsRecords(startTime, endTime);
        
        if (expiredRecords.isEmpty()) {
            log.info("没有需要处理的过期积分");
            return;
        }
        
        log.info("找到{}条过期积分记录", expiredRecords.size());
        
        // 按用户和积分类型分组处理
        Map<String, Integer> expiredPointsMap = new HashMap<>();
        
        for (JDWAPointsRecord record : expiredRecords) {
            String key = record.getUserId() + "_" + record.getPointsType();
            Integer expiredPoints = expiredPointsMap.getOrDefault(key, 0);
            expiredPoints += record.getPoints();
            expiredPointsMap.put(key, expiredPoints);
        }
        
        // 扣减过期积分
        for (Map.Entry<String, Integer> entry : expiredPointsMap.entrySet()) {
            String[] keyParts = entry.getKey().split("_");
            Long userId = Long.valueOf(keyParts[0]);
            String pointsType = keyParts[1];
            Integer points = entry.getValue();
            
            try {
                deductPoints(userId, points, pointsType, "POINTS_EXPIRE", null, "积分过期");
                log.info("用户{}的{}类型积分过期扣减{}积分", userId, pointsType, points);
            } catch (Exception e) {
                log.error("处理用户{}的过期积分失败: {}", userId, e.getMessage(), e);
            }
        }
        
        log.info("过期积分处理完成");
    }
}

/**
 * 活动完成后的积分奖励流程
 */
@Transactional(rollbackFor = Exception.class)
public JDWAActivity createActivity(Long userId, JDWAActivityRequest request) {
    // 创建活动记录...
    
    // 计算碳减排量
    BigDecimal carbonReduction = calculateCarbonReduction(
            request.getActivityType(), request.getDistance());
    activity.setCarbonReduction(carbonReduction);
    
    // 保存活动记录
    save(activity);
    
    // 计算并发放积分奖励
    JDWAPointsRecord pointsRecord = pointsService.rewardActivityPoints(
            userId, 
            activity.getId(), 
            "ACTIVITY_" + request.getActivityType(), 
            carbonReduction);
    
    // 更新活动记录中的积分奖励信息
    if (pointsRecord != null) {
        activity.setPointsEarned(pointsRecord.getPoints());
        updateById(activity);
    }
    
    // 检查是否达成成就
    achievementService.checkUserAchievements(userId);
    
    return activity;
}

@Transactional(rollbackFor = Exception.class)
public JDWAPointsRecord addPoints(Long userId, Integer points, String pointsType, 
        String businessType, String businessId, String description, LocalDateTime expireTime) {
    // 获取用户积分账户（加锁）
    JDWAUserPoints userPoints = getUserPointsAccountWithLock(userId, pointsType);
    
    try {
        // 更新用户积分
        Integer beforeBalance = userPoints.getPointsBalance();
        Integer afterBalance = beforeBalance + points;
        
        userPoints.setPointsBalance(afterBalance);
        userPoints.setTotalIncome(userPoints.getTotalIncome() + points);
        userPoints.setUpdateTime(LocalDateTime.now());
        
        userPointsMapper.updateById(userPoints);
        
        // 创建积分记录
        JDWAPointsRecord record = new JDWAPointsRecord();
        // 设置记录信息...
        
        pointsRecordMapper.insert(record);
        
        // 记录积分操作日志
        log.info("用户{}增加{}积分，业务类型：{}，业务ID：{}", 
                userId, points, businessType, businessId);
        
        return record;
    } catch (Exception e) {
        log.error("积分增加失败：{}，用户ID：{}，积分：{}", 
                e.getMessage(), userId, points, e);
        throw new JDWAServiceException("积分增加失败");
    }
}

/**
 * 获取用户积分账户（加锁）
 */
@Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRES_NEW)
public JDWAUserPoints getUserPointsAccountWithLock(Long userId, String pointsType) {
    LambdaQueryWrapper<JDWAUserPoints> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(JDWAUserPoints::getUserId, userId)
            .eq(JDWAUserPoints::getPointsType, pointsType)
            .last("FOR UPDATE");
    
    JDWAUserPoints userPoints = userPointsMapper.selectOne(queryWrapper);
    
    if (userPoints == null) {
        // 创建新账户
        userPoints = new JDWAUserPoints();
        // 设置账户信息...
        
        userPointsMapper.insert(userPoints);
    }
    
    return userPoints;
}

/**
 * 异步发放积分奖励
 */
@Async("pointsTaskExecutor")
public void asyncRewardPoints(Long userId, Long businessId, String businessType, 
        BigDecimal value, String description) {
    try {
        // 获取积分规则
        JDWAPointsRule rule = getPointsRule(businessType);
        if (rule == null || rule.getStatus() == 0) {
            log.warn("积分规则不存在或已禁用：{}", businessType);
            return;
        }
        
        // 计算积分
        Integer points = calculatePoints(rule, value);
        if (points <= 0) {
            return;
        }
        
        // 检查日限额
        if (rule.getDailyLimit() != null && rule.getDailyLimit() > 0) {
            Integer todayPoints = getTodayPointsByBusinessType(userId, businessType);
            if (todayPoints >= rule.getDailyLimit()) {
                log.info("用户{}今日{}类型积分已达上限：{}", userId, businessType, rule.getDailyLimit());
                return;
            }
            
            // 调整为不超过日限额
            if (todayPoints + points > rule.getDailyLimit()) {
                points = rule.getDailyLimit() - todayPoints;
            }
        }
        
        // 设置过期时间
        LocalDateTime expireTime = null;
        if (rule.getExpireDays() != null && rule.getExpireDays() > 0) {
            expireTime = LocalDateTime.now().plusDays(rule.getExpireDays());
        }
        
        // 发放积分
        addPoints(userId, points, rule.getPointsType(), businessType, 
                businessId == null ? null : businessId.toString(), description, expireTime);
        
    } catch (Exception e) {
        log.error("异步发放积分失败：{}，用户ID：{}，业务类型：{}", 
                e.getMessage(), userId, businessType, e);
    }
}