修改奖品bug

zxl

5 天以前 d900bdc7b712666cdeafe36f01e485f4672e4651

 framework/src/main/java/cn/lili/modules/lmk/service/impl/PrizeServiceImpl.java

@@ -10,12 +10,11 @@
import cn.lili.modules.lmk.domain.entity.*;
import cn.lili.modules.lmk.domain.form.AddPrizeNumForm;
import cn.lili.modules.lmk.domain.query.PrizeRecordTimeQuery;
import cn.lili.modules.lmk.domain.vo.PrizeDetailVO;
import cn.lili.modules.lmk.domain.vo.PrizeProbabilityVO;
import cn.lili.modules.lmk.domain.vo.PrizeRecordTimeVO;
import cn.lili.modules.lmk.domain.vo.PrizeResultVO;
import cn.lili.modules.lmk.domain.vo.*;
import cn.lili.modules.lmk.enums.general.*;
import cn.lili.modules.lmk.service.*;
import cn.lili.modules.member.entity.dos.Member;
import cn.lili.modules.member.service.MemberService;
import cn.lili.modules.order.order.entity.dos.Order;
import cn.lili.modules.order.order.service.OrderService;
import cn.lili.modules.promotion.entity.dos.Coupon;
@@ -74,6 +73,9 @@
    private final ShareActionService shareActionService;
    private final AddNumCheekService addNumCheekService;
    private final OrderService orderService;
    private final MemberService memberService;
    private final VideoService videoService;
    private final VideoAuditRecordService videoAuditRecordService;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -524,6 +526,7 @@
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result addPrizeNum(AddPrizeNumForm addPrizeNumForm) {
        //指定活动给指定活动添加没指定活动给默认活动添加
        String prizeActivityId = addPrizeNumForm.getPrizeActivityId();
@@ -547,180 +550,331 @@
            addPrizeNumForm.setUserId(currentUser.getId());

        }
        PrizeActivity activity = prizeActivityService.getById(addPrizeNumForm.getPrizeActivityId());
        if (activity == null) {
            throw new ServiceException("当前活动不存在");
        }
        if (!PrizeActivityStatusEnum.ON.name().equals(activity.getEnableStatus())) {
            throw new ServiceException("当前活动没开启");
        }
        Date date = new Date();
        //活动结束不需要添加
        if (date.after(activity.getEndTime())) {
            throw new ServiceException("当前活动已结束");
        }
        Integer maxPrize = activity.getMaxPrize();
        String userId = addPrizeNumForm.getUserId();
        List<PrizeNumber> prizeNumberList = getPrizeNumberList(activity.getId(), userId);
        if (prizeNumberList.size() >= maxPrize) {
            throw new ServiceException("抽奖次数已达到上限了");
        }
        PrizeUserActionEnum actionEnum = PrizeUserActionEnum.select(addPrizeNumForm.getAddType());
        if (actionEnum == null) {
            throw new ServiceException("当前类型不存在");
        }
        AddPrizeRule addPrizeRule = getAddPrizeRule(actionEnum.name());
        if (addPrizeRule == null) {
            return Result.ok().data(0);
        }
        List<PrizeNumber>  needAdd = new ArrayList<>();
        Integer addNum = addPrizeRule.getAddNum();
        if (addNum == null) {
            return Result.ok().data(0);
        }
        //判读添加后是否大于最大次数
        if (prizeNumberList.size()+addNum >= maxPrize){
            addNum = maxPrize-prizeNumberList.size();
        }
        boolean addFlag = false;
        //判断该类型当天是否添加过了
        for (PrizeNumber prizeNumber : prizeNumberList) {
            if (actionEnum.name().equals(prizeNumber.getUserAction())) {
                addFlag =  true;
                break;
            }
        }
        String extend = addPrizeNumForm.getExtend();
        JSONObject jsonObject = JSONObject.parseObject(extend);
        LambdaQueryWrapper<AddNumCheek> query = Wrappers.lambdaQuery();
        AddNumCheek addNumCheek = null;
        String orderSn = null;
        Order order = null;
        String ruleValue= null;
        switch (actionEnum) {
            case SHARE_GOODS_VIDEO:
                String shareId = jsonObject.getString("shareId");
                ShareAction shareAction = shareActionService.getById(shareId);
                if (shareAction == null) {
                    return Result.ok().data(0);
                }
                if (addFlag){
                    log.info("当前用户当天已经添加过了分享添加次数了-------->{}",userId);
                    return Result.ok().data(0);
                }
                break;
            case SHARE_USER_REGISTRY:
                String memberId = jsonObject.getString("memberId");
                query.eq(AddNumCheek::getType,PrizeUserActionEnum.SHARE_USER_REGISTRY.name())
                        .eq(AddNumCheek::getCheckNo, memberId);
                if (addNumCheekService.getOne(query) != null) {
                    log.info("当前用户已经被邀请过了----------------->{}",memberId);
                    return Result.ok().data(0);
                }
                addNumCheek =  new AddNumCheek();
                addNumCheek.setType(PrizeUserActionEnum.SHARE_USER_REGISTRY.name());
                addNumCheek.setUserId(userId);
                addNumCheek.setCheckNo(memberId);
                addNumCheekService.save(addNumCheek);
                break;
            case SHARE_USER_SHOPPING:
                 orderSn = jsonObject.getString("orderSn");
                //校验订单是否存在
                 order = orderService.getBySn(orderSn);
                if (order == null) {
                    log.info("分享用户购物订单不存在{}",orderSn);
                    return Result.ok().data(0);
                }
                query.eq(AddNumCheek::getType,PrizeUserActionEnum.SHARE_USER_SHOPPING.name())
                        .eq(AddNumCheek::getCheckNo, orderSn);
                if (addNumCheekService.getOne(query) != null) {
                    log.info("当前邀请订单已经被领取过了----------------->{}",orderSn);
                    return Result.ok().data(0);
                }
                addNumCheek = new AddNumCheek();
                addNumCheek.setType(PrizeUserActionEnum.SHARE_USER_SHOPPING.name());
                addNumCheek.setUserId(userId);
                addNumCheek.setCheckNo(orderSn);
                addNumCheekService.save(addNumCheek);
                break;
            case USER_STAY_TIME:
                //todo 通过用户行为分析获取数据进行判断
                 ruleValue = addPrizeRule.getRuleValue();

                if (addFlag){
                    log.info("当前用户当天已经添加过了停留时间添加次数了-------->{}",userId);
                    return Result.ok().data(0);
                }
                break;
            case USER_BUY_SUM_PRICE:
                 orderSn = jsonObject.getString("orderSn");
                //校验订单是否存在
                 order = orderService.getBySn(orderSn);
                if (order == null) {
                    log.info("用户购物订单不存在{}",orderSn);
                    return Result.ok().data(0);
                }
                ruleValue =  addPrizeRule.getRuleValue();
                double price = Double.parseDouble(ruleValue);
                Double flowPrice = order.getFlowPrice();
                if (flowPrice < price) {
                    log.info("当前购物订单金额小于添加要求----------------->{}",orderSn);
                    return Result.ok().data(0);
                }
                query.eq(AddNumCheek::getType,PrizeUserActionEnum.USER_BUY_SUM_PRICE.name())
                        .eq(AddNumCheek::getCheckNo, orderSn);
                if (addNumCheekService.getOne(query) != null) {
                    log.info("当前购物订单已经被领取过了----------------->{}",orderSn);
                    return Result.ok().data(0);
                }
                addNumCheek = new AddNumCheek();
                addNumCheek.setType(PrizeUserActionEnum.USER_BUY_SUM_PRICE.name());
                addNumCheek.setUserId(userId);
                addNumCheek.setCheckNo(orderSn);
                addNumCheekService.save(addNumCheek);
                break;
            case USER_BUY_ORDER_NUM:
                orderSn = jsonObject.getString("orderSn");
                //校验订单是否存在
                order = orderService.getBySn(orderSn);
                if (order == null) {
                    log.info("用户购物数量订单不存在{}",orderSn);
                    return Result.ok().data(0);
                }
                query.eq(AddNumCheek::getType,PrizeUserActionEnum.USER_BUY_ORDER_NUM.name())
                        .eq(AddNumCheek::getCheckNo, orderSn);
                if (addNumCheekService.getOne(query) != null) {
                    log.info("当前购物订单数量已经被领取过了----------------->{}",orderSn);
                    return Result.ok().data(0);
                }
                addNumCheek = new AddNumCheek();
                addNumCheek.setType(PrizeUserActionEnum.USER_BUY_ORDER_NUM.name());
                addNumCheek.setUserId(userId);
                addNumCheek.setCheckNo(orderSn);
                addNumCheekService.save(addNumCheek);
                break;
            case USER_SCAN_STORE:
                break;
            case USER_PUBLISH_EXAMINE:

                break;
            default:
        String shareId =null;
        if (jsonObject != null) {
            shareId  = jsonObject.getString("shareId");
        }
        Date date = new Date();
        ShareAction shareAction =null;
        //分享进来的需要添加分享的用户
        if (StringUtils.isNotBlank(shareId)) {
            shareAction  = shareActionService.getById(shareId);
            String userId = shareAction.getUserId();
            addPrizeNumForm.setUserId(userId);
            Date createTime = shareAction.getCreateTime();
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(createTime); // 将Date设置到Calendar中
            calendar.add(Calendar.DAY_OF_MONTH, 1); // 加一天
            Date nextDay = calendar.getTime();
            //判断是否是新用户
            if (nextDay.before(date)) {
                //当前分享不是今天的分享
                log.info("当前分享不是今天的分享{}",shareId);
                return Result.ok().data(0);
            }
            // 除了视频外需要校验用户是否自己点击了自己的分享
            PrizeUserActionEnum actionEnum = PrizeUserActionEnum.select(addPrizeNumForm.getAddType());
            if (actionEnum == null) {
                log.info("当前类型不存在");
                return Result.ok().data(0);
            }
            if (!PrizeUserActionEnum.SHARE_GOODS_VIDEO.name().equals(actionEnum.name())) {
                if (currentUser.getId().equals(userId)) {
                    //分享的用户自己点击了
                    log.info("用户自己点击了自己的分享");
                    return Result.ok().data(0);
                }
            }

        }
        //设置默认抽奖次数并返回默认抽奖次数
        for (int i = 0; i < addNum; i++) {
            PrizeNumber prizeNumber = new PrizeNumber();
            prizeNumber.setActivityPrizeId(Long.parseLong(addPrizeNumForm.getPrizeActivityId()));
            prizeNumber.setUserId(Long.parseLong(userId));
            prizeNumber.setUserAction(actionEnum.name());
            prizeNumber.setUseStatus(PrizeNumberUseEnum.WAIT.name());
            needAdd.add(prizeNumber);

        String userId = addPrizeNumForm.getUserId();
        RLock lock = redissonClient.getLock(PRIZE_ADD_NUM + userId);
        try {

            lock.lock();
            PrizeActivity activity = prizeActivityService.getById(addPrizeNumForm.getPrizeActivityId());
            if (activity == null) {
                throw new ServiceException("当前活动不存在");
            }
            if (!PrizeActivityStatusEnum.ON.name().equals(activity.getEnableStatus())) {
                throw new ServiceException("当前活动没开启");
            }
            //活动结束不需要添加
            if (date.after(activity.getEndTime())) {
                throw new ServiceException("当前活动已结束");
            }
            Integer maxPrize = activity.getMaxPrize();
            List<PrizeNumber> prizeNumberList = getPrizeNumberList(activity.getId(), userId);
            if (prizeNumberList.size() >= maxPrize) {
                throw new ServiceException("抽奖次数已达到上限了");
            }
            PrizeUserActionEnum actionEnum = PrizeUserActionEnum.select(addPrizeNumForm.getAddType());
            if (actionEnum == null) {
                throw new ServiceException("当前类型不存在");
            }
            AddPrizeRule addPrizeRule = getAddPrizeRule(actionEnum.name());
            if (addPrizeRule == null) {
                return Result.ok().data(0);
            }
            List<PrizeNumber> needAdd = new ArrayList<>();
            Integer addNum = addPrizeRule.getAddNum();
            if (addNum == null) {
                return Result.ok().data(0);
            }
            //判读添加后是否大于最大次数
            if (prizeNumberList.size() + addNum >= maxPrize) {
                addNum = maxPrize - prizeNumberList.size();
            }
            boolean addFlag = false;
            //判断该类型当天是否添加过了
            for (PrizeNumber prizeNumber : prizeNumberList) {
                if (actionEnum.name().equals(prizeNumber.getUserAction())) {
                    addFlag = true;
                    break;
                }
            }
            LambdaQueryWrapper<AddNumCheek> query = Wrappers.lambdaQuery();
            AddNumCheek addNumCheek = null;
            String orderSn = null;
            Order order = null;
            String ruleValue = null;
            switch (actionEnum) {
                case SHARE_GOODS_VIDEO:
                    if (shareAction == null) {
                        log.info("当前用户没有分享{}",userId);
                        return Result.ok().data(0);
                    }
                    if (addFlag) {
                        log.info("当前用户当天已经添加过了分享添加次数了-------->{}", userId);
                        return Result.ok().data(0);
                    }
                    break;
                case SHARE_USER_REGISTRY:
                    if (shareAction == null) {
                        log.info("当前用户没有分享{}",userId);
                        return Result.ok().data(0);
                    }
                    Member member = memberService.getById(shareAction.getUserId());
                    Date createTime = member.getCreateTime();
                    Calendar calendar = Calendar.getInstance();
                    calendar.setTime(createTime); // 将Date设置到Calendar中
                    calendar.add(Calendar.DAY_OF_MONTH, 1); // 加一天
                    Date nextDay = calendar.getTime();
                    //判断是否是新用户
                    if (nextDay.before(date)) {
                        //当前用户不是新用户
                        log.info("当前用户不是新用户{}",currentUser.getId());
                        return Result.ok().data(0);
                    }
                    query.eq(AddNumCheek::getType, PrizeUserActionEnum.SHARE_USER_REGISTRY.name())
                            .eq(AddNumCheek::getCheckNo, currentUser.getId());
                    if (addNumCheekService.getOne(query) != null) {
                        log.info("当前用户已经被邀请过了----------------->{}", currentUser.getId());
                        return Result.ok().data(0);
                    }
                    addNumCheek = new AddNumCheek();
                    addNumCheek.setType(PrizeUserActionEnum.SHARE_USER_REGISTRY.name());
                    addNumCheek.setUserId(userId);
                    addNumCheek.setCheckNo(currentUser.getId());
                    addNumCheekService.save(addNumCheek);
                    break;
                case SHARE_USER_SHOPPING:
                    orderSn = jsonObject.getString("orderSn");
                    //校验订单是否存在
                    order = orderService.getBySn(orderSn);
                    if (order == null) {
                        log.info("分享用户购物订单不存在{}", orderSn);
                        return Result.ok().data(0);
                    }
                    query.eq(AddNumCheek::getType, PrizeUserActionEnum.SHARE_USER_SHOPPING.name())
                            .eq(AddNumCheek::getCheckNo, orderSn);
                    if (addNumCheekService.getOne(query) != null) {
                        log.info("当前邀请订单已经被领取过了----------------->{}", orderSn);
                        return Result.ok().data(0);
                    }
                    addNumCheek = new AddNumCheek();
                    addNumCheek.setType(PrizeUserActionEnum.SHARE_USER_SHOPPING.name());
                    addNumCheek.setUserId(userId);
                    addNumCheek.setCheckNo(orderSn);
                    addNumCheekService.save(addNumCheek);
                    break;
                case USER_STAY_TIME:
                    if (addFlag) {
                        log.info("当前用户当天已经添加过了停留时间添加次数了-------->{}", userId);
                        return Result.ok().data(0);
                    }
                    ruleValue = addPrizeRule.getRuleValue();
                    LocalDate now = LocalDate.now();
                    LocalDateTime begin = LocalDateTime.of(now, LocalTime.MIN);
                    LocalDateTime end = LocalDateTime.of(now, LocalTime.MAX);
                    BigDecimal toDayStayTime = actionRecordService.getToDayStayTime(currentUser.getId(), begin, end);
                    BigDecimal divide = toDayStayTime.divide(new BigDecimal(60), 2, RoundingMode.HALF_UP);
                    if (divide.compareTo(new BigDecimal(ruleValue)) < 0) {
                        log.info("当前用户停留时间不足无法增加次数");
                        return Result.ok().data(0);
                    }
                    break;
                case USER_BUY_SUM_PRICE:
                    orderSn = jsonObject.getString("orderSn");
                    //校验订单是否存在
                    order = orderService.getBySn(orderSn);
                    if (order == null) {
                        log.info("用户购物订单不存在{}", orderSn);
                        return Result.ok().data(0);
                    }
                    ruleValue = addPrizeRule.getRuleValue();
                    double price = Double.parseDouble(ruleValue);
                    Double flowPrice = order.getFlowPrice();
                    if (flowPrice < price) {
                        log.info("当前购物订单金额小于添加要求----------------->{}", orderSn);
                        return Result.ok().data(0);
                    }
                    query.eq(AddNumCheek::getType, PrizeUserActionEnum.USER_BUY_SUM_PRICE.name())
                            .eq(AddNumCheek::getCheckNo, orderSn);
                    if (addNumCheekService.getOne(query) != null) {
                        log.info("当前购物订单已经被领取过了----------------->{}", orderSn);
                        return Result.ok().data(0);
                    }
                    addNumCheek = new AddNumCheek();
                    addNumCheek.setType(PrizeUserActionEnum.USER_BUY_SUM_PRICE.name());
                    addNumCheek.setUserId(userId);
                    addNumCheek.setCheckNo(orderSn);
                    addNumCheekService.save(addNumCheek);
                    break;
                case USER_BUY_ORDER_NUM:
                    orderSn = jsonObject.getString("orderSn");
                    //校验订单是否存在
                    order = orderService.getBySn(orderSn);
                    if (order == null) {
                        log.info("用户购物数量订单不存在{}", orderSn);
                        return Result.ok().data(0);
                    }
                    query.eq(AddNumCheek::getType, PrizeUserActionEnum.USER_BUY_ORDER_NUM.name())
                            .eq(AddNumCheek::getCheckNo, orderSn);
                    if (addNumCheekService.getOne(query) != null) {
                        log.info("当前购物订单数量已经被领取过了----------------->{}", orderSn);
                        return Result.ok().data(0);
                    }
                    addNumCheek = new AddNumCheek();
                    addNumCheek.setType(PrizeUserActionEnum.USER_BUY_ORDER_NUM.name());
                    addNumCheek.setUserId(userId);
                    addNumCheek.setCheckNo(orderSn);
                    addNumCheekService.save(addNumCheek);
                    break;
                case USER_SCAN_STORE:
                    break;
                case USER_PUBLISH_EXAMINE:
                    String videoId = jsonObject.getString("videoId");
                    query.eq(AddNumCheek::getType, PrizeUserActionEnum.USER_PUBLISH_EXAMINE.name())
                            .eq(AddNumCheek::getCheckNo, videoId);
                    if (addNumCheekService.getOne(query) != null) {
                        log.info("当前视频审核已经发放过了----------------->{}", videoId);
                        return Result.ok().data(0);
                    }
                    Video video = videoService.getById(videoId);
                    if (video == null) {
                        log.info("当前视频不存在{}",videoId);
                        return Result.ok().data(0);
                    }
                    String status = video.getStatus();
                    if (!"1".equals(status)) {
                        log.info("当前视频没有审核通过{}",videoId);
                        return Result.ok().data(0);
                    }
                    LambdaQueryWrapper<VideoAuditRecord> eq = Wrappers.<VideoAuditRecord>lambdaQuery()
                            .eq(VideoAuditRecord::getVideoId, videoId)
                            .eq(VideoAuditRecord::getAuditSuccess, true);
                    List<VideoAuditRecord> list = videoAuditRecordService.list(eq);
                    if (list.isEmpty()) {
                        log.info("当前视频没有审核通过{}",videoId);
                        return Result.ok().data(0);
                    }
                    addNumCheek = new AddNumCheek();
                    addNumCheek.setType(PrizeUserActionEnum.USER_PUBLISH_EXAMINE.name());
                    addNumCheek.setUserId(userId);
                    addNumCheek.setCheckNo(videoId);
                    addNumCheekService.save(addNumCheek);
                    break;
                default:
                    return Result.ok().data(0);
            }
            //设置默认抽奖次数并返回默认抽奖次数
            for (int i = 0; i < addNum; i++) {
                PrizeNumber prizeNumber = new PrizeNumber();
                prizeNumber.setActivityPrizeId(Long.parseLong(addPrizeNumForm.getPrizeActivityId()));
                prizeNumber.setUserId(Long.parseLong(userId));
                prizeNumber.setUserAction(actionEnum.name());
                prizeNumber.setUseStatus(PrizeNumberUseEnum.WAIT.name());
                needAdd.add(prizeNumber);
            }
            prizeNumberService.saveBatch(needAdd);
            return Result.ok().data(0);
        } finally {
            TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                @Override
                public void afterCommit() {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }

                @Override
                public void afterCompletion(int status) {
                    if (lock.isHeldByCurrentThread()) {
                        lock.unlock();
                    }
                }
            });
        }
        prizeNumberService.saveBatch(needAdd);
        return Result.ok().data(0);
    }
    public  AddPrizeRule getAddPrizeRule(String ruleCode) {

    public AddPrizeRule getAddPrizeRule(String ruleCode) {
        LambdaQueryWrapper<AddPrizeRule> one = Wrappers.<AddPrizeRule>lambdaQuery().eq(AddPrizeRule::getRuleCode, ruleCode);
       return addPrizeRuleService.getOne(one);
        return addPrizeRuleService.getOne(one);
    }

    @Override
    public Result getPrizeRule() {
        List<AddPrizeRule> list = addPrizeRuleService.list(Wrappers.<AddPrizeRule>lambdaQuery().orderByDesc(AddPrizeRule::getId));
        AuthUser currentUser = UserContext.getCurrentUser();
        if (Objects.nonNull(currentUser)) {
            String id = currentUser.getId();
            LambdaQueryWrapper<PrizeActivity> eq = Wrappers.<PrizeActivity>lambdaQuery()
                    .eq(PrizeActivity::getDeleteFlag, Boolean.FALSE)
                    .eq(PrizeActivity::getEnableStatus, PrizeActivityStatusEnum.ON.name())
                    .eq(PrizeActivity::getPopup, Boolean.TRUE);
            List<PrizeActivity> activities = prizeActivityService.list(eq);
            PrizeActivity activity = activities.get(0);
            if (Objects.nonNull(activity)) {
                try {
                    List<PrizeNumber> prizeNumberList = getPrizeNumberList(activity.getId(), id);
                    Set<String> completedActionSet = prizeNumberList.stream().map(PrizeNumber::getUserAction).collect(Collectors.toSet());
                    List<AddPrizeRule> finalRuleList = list.stream()
                            .map(rule -> {
                                if (Objects.isNull(rule.getRuleCode())) {
                                    return rule;
                                }
                                boolean isCompleted = completedActionSet.contains(rule.getRuleCode());
                                if (!isCompleted) {
                                    return rule;
                                }
                                AddPrizeRule completedRule = new AddPrizeRule();
                                BeanUtils.copyProperties(rule, completedRule);
                                String originalName = Optional.ofNullable(completedRule.getRuleName()).orElse("");
                                if (!originalName.contains("(已完成)")) {
                                    completedRule.setRuleName(originalName + "(已完成)");
                                }
                                return completedRule;
                            }).collect(Collectors.toList());
                    return Result.ok().data(finalRuleList);
                } catch (Exception e) {
                    return Result.ok().data(list);
                }
            }
        }
        return Result.ok().data(list);
    }
}