refactor(mall): 优化活动报名相关功能

Administrator

5 days ago 6e3fcdbde6ad62832753ddc8d3e1429f29ea58ee

 src/main/java/cc/mrbird/febs/mall/service/impl/HappyActivityServiceImpl.java

@@ -7,19 +7,14 @@
import cc.mrbird.febs.common.utils.MallUtils;
import cc.mrbird.febs.common.utils.ShareCodeUtil;
import cc.mrbird.febs.mall.dto.*;
import cc.mrbird.febs.mall.dto.activity.ApiActivityOrderListDto;
import cc.mrbird.febs.mall.dto.activity.ApiCheckOrderDto;
import cc.mrbird.febs.mall.dto.activity.ApiVoteOptionInPageDto;
import cc.mrbird.febs.mall.dto.activity.*;
import cc.mrbird.febs.mall.entity.*;
import cc.mrbird.febs.mall.mapper.*;
import cc.mrbird.febs.mall.service.HappyActivityService;
import cc.mrbird.febs.mall.service.IApiMallMemberWalletService;
import cc.mrbird.febs.mall.vo.*;
import cc.mrbird.febs.mall.dto.ApiOperateDoDto;
import cc.mrbird.febs.mall.vo.activity.ApiActivityOrderInfoVo;
import cc.mrbird.febs.mall.vo.activity.ApiActivityOrderListVo;
import cc.mrbird.febs.mall.vo.activity.ApiCheckOrderVo;
import cc.mrbird.febs.mall.vo.activity.ApiVoteActivityHotVo;
import cc.mrbird.febs.mall.vo.activity.*;
import cc.mrbird.febs.pay.model.BrandWCPayRequestData;
import cc.mrbird.febs.pay.service.IXcxPayService;
import cc.mrbird.febs.rabbit.producter.AgentProducer;
@@ -32,7 +27,6 @@
import cn.hutool.crypto.SecureUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
@@ -57,6 +51,7 @@
    private final HappyActivityOptionMapper happyActivityOptionMapper;
    private final HappyActivityConnectMapper happyActivityConnectMapper;
    private final HappyActivityOrderMapper happyActivityOrderMapper;
    private final HappyActivityCommentMapper happyActivityCommentMapper;
    private final HappyActivityOrderItemMapper happyActivityOrderItemMapper;
    private final IXcxPayService iXcxPayService;
    private final IApiMallMemberWalletService iApiMallMemberWalletService;
@@ -73,56 +68,33 @@
        // 检查分页结果是否包含数据
        if(CollUtil.isNotEmpty(happyActivityPage.getRecords())){
            List<ApiActivityInfoVo> records = happyActivityPage.getRecords();
            // 使用Stream流操作records，获取所有活动的ID
            List<Long> ids = records.stream().map(ApiActivityInfoVo::getId).collect(Collectors.toList());

            // 查询关注点赞转发记录，筛选出关注活动类型且未删除的关注记录，并按ID升序排序，限制结果数量为3
            List<HappyFollow> happyFollows = happyFollowMapper.selectList(
                    new LambdaQueryWrapper<HappyFollow>()
                            .select(HappyFollow::getMemberId)
                            .eq(HappyFollow::getSourceType, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode())
                            .in(HappyFollow::getSourceId, ids)
                            .eq(HappyFollow::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                            .orderByAsc(HappyFollow::getId)
                            .last("limit 3")
            );

            // 检查关注记录是否不为空
            if(CollUtil.isNotEmpty(happyFollows)){
                // 使用Stream流操作关注记录，获取所有成员ID的集合
                Set<Long> memberIds = happyFollows.stream().collect(Collectors.mapping(HappyFollow::getMemberId, Collectors.toSet()));

                // 查询成员信息，获取成员的ID和头像
                List<MallMember> mallMembers = mallMemberMapper.selectList(
                        new LambdaQueryWrapper<MallMember>()
                                .select(MallMember::getId,MallMember::getAvatar)
                                .in(MallMember::getId, memberIds)
            // 遍历活动记录，为每个活动添加成员头像信息
            records.forEach(record -> {
                // 查询关注点赞转发记录，筛选出关注活动类型且未删除的关注记录，并按ID升序排序，限制结果数量为3
                List<HappyFollow> happyFollows = happyFollowMapper.selectList(
                        new LambdaQueryWrapper<HappyFollow>()
                                .eq(HappyFollow::getSourceType, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode())
                                .eq(HappyFollow::getSourceId, record.getId())
                                .eq(HappyFollow::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                                .groupBy(HappyFollow::getMemberId)
                                .orderByAsc(HappyFollow::getId)
                                .last("limit 3")
                );
                // 检查关注记录是否不为空
                if(CollUtil.isNotEmpty(happyFollows)){
                    // 使用Stream流操作关注记录，获取所有成员ID的集合
                    Set<Long> memberIds = happyFollows.stream().collect(Collectors.mapping(HappyFollow::getMemberId, Collectors.toSet()));

                // 使用Stream流操作成员信息，生成一个以成员ID为键，成员信息为值的Map
                Map<Long, MallMember> memberMap = mallMembers.stream()
                        .collect(Collectors.toMap(MallMember::getId, member -> member));

                // 使用Stream流操作关注记录，生成一个以活动ID为键，成员ID列表为值的Map
                Map<Long, List<Long>> followMap = happyFollows.stream()
                        .collect(Collectors.groupingBy(
                                HappyFollow::getSourceId,
                                Collectors.mapping(HappyFollow::getMemberId, Collectors.toList())
                        ));

                // 遍历活动记录，为每个活动添加成员头像信息
                records.forEach(record -> {
                    List<Long> memberIdsForRecord = followMap.get(record.getId());
                    if (CollUtil.isNotEmpty(memberIdsForRecord)) {
                        List<String> memberAvatars = memberIdsForRecord.stream()
                                .map(memberMap::get)
                                .filter(member -> member != null)
                                .map(MallMember::getAvatar)
                                .collect(Collectors.toList());
                        record.setMemberAvatars(memberAvatars);
                    }
                });
            }
                    // 查询成员信息，获取成员的ID和头像
                    List<MallMember> mallMembers = mallMemberMapper.selectList(
                            new LambdaQueryWrapper<MallMember>()
                                    .select(MallMember::getAvatar)
                                    .in(MallMember::getId, memberIds)
                    );
                    List<String> memberAvatars = mallMembers.stream().map(MallMember::getAvatar).collect(Collectors.toList());
                    record.setMemberAvatars(memberAvatars);
                }
            });
        }
        // 返回成功响应，包含活动分页数据
        return new FebsResponse().success().data(happyActivityPage);
@@ -140,6 +112,33 @@
        );
        if(happyActivity != null){
            BeanUtil.copyProperties(happyActivity,apiActivityVo);

            Integer commentCount = happyActivityCommentMapper.selectCount(
                    new LambdaQueryWrapper<HappyActivityComment>()
                            .eq(HappyActivityComment::getActivityId, happyActivity.getId())
                            .eq(HappyActivityComment::getShowState, StateUpDownEnum.UP.getCode())
            );
            apiActivityVo.setCommentCount(commentCount);

            List<HappyFollow> happyFollows = happyFollowMapper.selectList(
                    new LambdaQueryWrapper<HappyFollow>()
                            .select(HappyFollow::getId, HappyFollow::getType)
                            .eq(HappyFollow::getSourceType, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode())
                            .eq(HappyFollow::getSourceId, happyActivity.getId())
                            .in(HappyFollow::getType, Arrays.asList(StateUpDownEnum.LIKE.getCode(), StateUpDownEnum.SHARE.getCode()))
                            .eq(HappyFollow::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
            );
            if(CollUtil.isNotEmpty(happyFollows)){
                //  使用Stream流操作happyFollows，按照type分类，返回每一个不同type的总数量，并返回一个Map
                Map<Integer, Long> typeCountMap = happyFollows.stream()
                        .collect(Collectors.groupingBy(HappyFollow::getType, Collectors.counting()));
                Long zanCnt = ObjectUtil.defaultIfNull(typeCountMap.get(StateUpDownEnum.LIKE.getCode()), 0L);
                apiActivityVo.setZanCnt(Math.toIntExact(zanCnt));
                Long sendCnt = ObjectUtil.defaultIfNull(typeCountMap.get(StateUpDownEnum.SHARE.getCode()), 0L);
                apiActivityVo.setSendCnt(Math.toIntExact(sendCnt));
            }


        }
        return new FebsResponse().success().data(apiActivityVo);
    }
@@ -153,6 +152,14 @@
    }

    @Override
    public FebsResponse voteOptionRecordInPage(ApiVoteOptionRecordInPageDto dto) {
        // 创建分页对象，传入当前页和每页大小
        Page<ApiActivityOptionListVo> page = new Page<>(dto.getPageNow(), dto.getPageSize());
        Page<ApiActivityOptionListVo> voteRecordInPage = this.baseMapper.getVoteOptionRecordInPage(page, dto);
        return new FebsResponse().success().data(voteRecordInPage);
    }

    @Override
    public FebsResponse voteOption(Long id) {

        ApiActivityOptionVo apiActivityOptionVo = new ApiActivityOptionVo();
@@ -160,6 +167,44 @@
        if(happyActivityOption != null){
            BeanUtil.copyProperties(happyActivityOption, apiActivityOptionVo);
        }

        //投票人数
        List<HappyFollow> happyFollows = happyFollowMapper.selectList(
                new LambdaQueryWrapper<HappyFollow>()
                        .select(HappyFollow::getId)
                        .eq(HappyFollow::getSourceOptionId, id)
                        .eq(HappyFollow::getType, StateUpDownEnum.VOTE.getCode())
                        .eq(HappyFollow::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                        .groupBy(HappyFollow::getMemberId)
        );
        apiActivityOptionVo.setVoteCnt(CollUtil.isNotEmpty(happyFollows) ? happyFollows.size() : 0);

        List<HappyActivityOption> happyActivityOptions = happyActivityOptionMapper.selectList(
                new LambdaQueryWrapper<HappyActivityOption>()
                        .select(HappyActivityOption::getId,HappyActivityOption::getLikesCnt)
                        .eq(HappyActivityOption::getActivityId, happyActivityOption.getActivityId())
                        .eq(HappyActivityOption::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                        .eq(HappyActivityOption::getState, StateUpDownEnum.VOTE_OPTION_STATE_AUDIT_SUCCESS.getCode())
                .orderByDesc(HappyActivityOption::getLikesCnt)
        );
        //获取上一个名次的数据
        int firstCnt = 1;
        int distanceCnt = 0;
        for (HappyActivityOption option : happyActivityOptions){
            if(option.getId().equals(id)){
                apiActivityOptionVo.setFirstCnt(firstCnt);
                if( firstCnt == 1 ){
                    apiActivityOptionVo.setDistanceCnt(distanceCnt);
                }else{
                    apiActivityOptionVo.setDistanceCnt(distanceCnt- option.getLikesCnt());
                }
                break;
            }else{
                firstCnt = firstCnt + 1;
                distanceCnt = option.getLikesCnt();
            }
        }

        return new FebsResponse().success().data(apiActivityOptionVo);
    }

@@ -178,16 +223,18 @@
                    throw new FebsException("活动不存在");
                }

                if (StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode() == happyActivity.getType()) {
                    Long sourceOptionId = dto.getSourceOptionId();
                    if (sourceOptionId == null) {
                        throw new FebsException("选项ID不能为空");
                    }
                    this.operateDoVote(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, sourceOptionId, type);
                    this.addLikeCnt(sourceOptionId);
                } else {
                    this.operateDo(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, type);
                }
                this.operateDo(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, type);

//                if (StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode() == happyActivity.getType()) {
//                    Long sourceOptionId = dto.getSourceOptionId();
//                    if (sourceOptionId == null) {
//                        throw new FebsException("选项ID不能为空");
//                    }
//                    this.operateDoVote(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, sourceOptionId, type);
//                    this.addLikeCnt(sourceOptionId);
//                } else {
//                    this.operateDo(memberId, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode(), sourceId, type);
//                }
            } else if (StateUpDownEnum.SOURCE_TYPE_SOCIAL_CIRCLE.getCode() == sourceType) {
                // 朋友圈点赞或关注
                this.operateDo(memberId, StateUpDownEnum.SOURCE_TYPE_SOCIAL_CIRCLE.getCode(), sourceId, type);
@@ -254,7 +301,6 @@
                new LambdaQueryWrapper<HappyFollow>()
                        .eq(HappyFollow::getMemberId, memberId)
                        .eq(HappyFollow::getSourceId, sourceId)
                        .eq(HappyFollow::getSourceOptionId, sourceOptionId)
                        .eq(HappyFollow::getType, type)
                        .gt(HappyFollow::getCreatedTime, DateUtil.beginOfDay(new Date()))
        );
@@ -276,7 +322,7 @@
        if(CollUtil.isNotEmpty(records)){
            //stream流操作records，获取全部的memberId(全部投票人)
            Set<Long> memberIds = records.stream().map(ApiVoteRecordInPageVo::getMemberId).collect(Collectors.toSet());
            if(CollUtil.isEmpty(memberIds)){
            if(CollUtil.isNotEmpty(memberIds)){
                List<MallMember> mallMembers = mallMemberMapper.selectList(
                        new LambdaQueryWrapper<MallMember>()
                                .select(MallMember::getId, MallMember::getName, MallMember::getAvatar)
@@ -295,6 +341,31 @@


        return new FebsResponse().success().data(voteRecordInPage);
    }

    @Override
    public FebsResponse operateValidRegister(ApiOperateValidRegisterActivityDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();
        HappyActivity happyActivity = this.baseMapper.selectById(dto.getActivityId());

        if (StateUpDownEnum.ACTIVITY_STATE_END.getCode() == happyActivity.getState()) {
            throw new FebsException("活动已结束");
        }
        if (StateUpDownEnum.DOWN.getCode() == happyActivity.getAddState()) {
            throw new FebsException("活动尚未开启报名");
        }
        //判断用户是否重复报名
        Integer registerCnt = happyActivityOptionMapper.selectCount(
                new LambdaQueryWrapper<HappyActivityOption>()
                        .eq(HappyActivityOption::getMemberId, memberId)
                        .eq(HappyActivityOption::getActivityId, dto.getActivityId())
                        .ne(HappyActivityOption::getState, StateUpDownEnum.VOTE_OPTION_STATE_AUDIT_REFUSE.getCode())
                        .eq(HappyActivityOption::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
        );
        if (registerCnt > 0) {
            throw new FebsException("您已经报名过了");
        }
        return new FebsResponse().success();
    }

    @Override
@@ -344,6 +415,7 @@
                new LambdaQueryWrapper<HappyActivityConnect>()
                        .eq(HappyActivityConnect::getMemberId, memberId)
                        .eq(HappyActivityConnect::getName, dto.getName())
                        .eq(HappyActivityConnect::getPhone, dto.getPhone())
        );
        if(CollUtil.isNotEmpty(happyActivityConnects)){
            throw new FebsException("已经添加过该联系人");
@@ -400,6 +472,26 @@
    }

    @Override
    public FebsResponse expireOrder(ApiExpireOrderDto dto) {
        if(CollUtil.isEmpty(dto.getIds())){
            throw new FebsException("请选择订单");
        }

        dto.getIds().forEach(id -> {
            HappyActivityOrder happyActivityOrder = happyActivityOrderMapper.selectById(id);
            if(ObjectUtil.isNotEmpty(happyActivityOrder)){
                Long activityId = happyActivityOrder.getActivityId();
                Integer numCnt = happyActivityOrder.getNumCnt();
                this.baseMapper.updateHappyActivitySurplusCnt(activityId,numCnt);

                happyActivityOrder.setState(StateUpDownEnum.ORDER_STATE_OVERTIME.getCode());
                happyActivityOrderMapper.updateById(happyActivityOrder);
            }
        });
        return new FebsResponse().success();
    }

    @Override
    public FebsResponse createOrder(ApiCreateOrderDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();
        if(CollUtil.isEmpty(dto.getConnectIds())){
@@ -413,20 +505,45 @@
        }

        Long activityId = dto.getActivityId();

        List<HappyActivityOrderItem> happyActivityOrderItems = happyActivityOrderItemMapper.selectList(
                new LambdaQueryWrapper<HappyActivityOrderItem>()
                        .eq(HappyActivityOrderItem::getActivityId, activityId)
                        .in(HappyActivityOrderItem::getConnectId, connectIds)
        );
        if(CollUtil.isNotEmpty(happyActivityOrderItems)){
            //stream流操作happyActivityOrderItems，返回一个orderId的Set集合
            Set<Long> orderIdSet = happyActivityOrderItems.stream().map(HappyActivityOrderItem::getOrderId).collect(Collectors.toSet());
            List<HappyActivityOrder> happyActivityOrders = happyActivityOrderMapper.selectList(
                    new LambdaQueryWrapper<HappyActivityOrder>()
                            .in(HappyActivityOrder::getId, orderIdSet)
                            .in(HappyActivityOrder::getState, Arrays.asList(StateUpDownEnum.ORDER_STATE_WAIT_PAY.getCode(),StateUpDownEnum.ORDER_STATE_WAIT_USE.getCode()))
            );
            if(CollUtil.isNotEmpty(happyActivityOrders)){
                throw new FebsException("有报名人重复报名了活动，请重新选择");
            }
        }
        HappyActivity happyActivity = this.baseMapper.selectById(activityId);
        if (ObjectUtil.isEmpty(happyActivity)) {
            throw new FebsException("活动不存在");
        }
        if (StateUpDownEnum.ACTIVITY_STATE_NOT_START.getCode() == happyActivity.getState()) {
            throw new FebsException("活动尚未开始");
        }
        if (StateUpDownEnum.ACTIVITY_STATE_END.getCode() == happyActivity.getState()) {
            throw new FebsException("活动已结束");
        }

        Integer joinCnt = happyActivity.getJoinCnt();
        if(joinCnt < numCnt){
            throw new FebsException("报名额度剩下"+joinCnt+"，请减少报名人数");
        Integer surplusCnt = happyActivity.getSurplusCnt();
        if(surplusCnt < numCnt){
            throw new FebsException("报名额度剩下"+surplusCnt+"，请减少报名人数");
        }
        //支付总金额
        BigDecimal amount = happyActivity.getPayAmount().multiply(new BigDecimal(dto.getNumCnt())).setScale(2, RoundingMode.DOWN);
        if(amount.compareTo(BigDecimal.ZERO) < 0){
            throw new FebsException("支付金额错误");
        }
        DateTime failTime = DateUtil.offsetMinute(new Date(), StateUpDownEnum.ORDER_OVERTIME.getCode());
        HappyActivityOrder happyActivityOrder = new HappyActivityOrder();
        happyActivityOrder.setOrderNo(MallUtils.getOrderNum());
        happyActivityOrder.setMemberId(memberId);
@@ -435,6 +552,9 @@
        happyActivityOrder.setNumCnt(dto.getNumCnt());
        happyActivityOrder.setAmount(amount);
        happyActivityOrder.setPayState(StateUpDownEnum.PAY_STATE_NOT_PAY.getCode());
        happyActivityOrder.setPayType(StateUpDownEnum.PAY_METHOD_WECHAT.getCode());
        happyActivityOrder.setFailTime(failTime);
        log.info("创建订单，订单号="+JSONUtil.parse(happyActivityOrder));
        happyActivityOrderMapper.insert(happyActivityOrder);

        for(Long connectId : connectIds){
@@ -453,10 +573,12 @@
            happyActivityOrderItemMapper.insert(happyActivityOrderItem);
        }

        this.substructJoinCnt(activityId, happyActivityOrder.getNumCnt());
        this.baseMapper.updateHappyActivitySurplusCnt(activityId, happyActivityOrder.getNumCnt() * (-1));

        HashMap<String, Object> stringObjectHashMap = new HashMap<>();
        stringObjectHashMap.put("orderId",happyActivityOrder.getId());
        stringObjectHashMap.put("amount",amount);
        stringObjectHashMap.put("failTime",failTime);

        return new FebsResponse().success().data(stringObjectHashMap);
    }
@@ -521,8 +643,6 @@
            throw new FebsException("支付失败：" + e.getMessage());
        }

        // todo 支付失败要把对应的人数加回来

        // 构造返回结果，包含支付相关信息
        Map<String, Object> map = new HashMap<>();
        map.put("orderInfo", payResultStr);
@@ -540,17 +660,6 @@
        happyActivityOption.setLikesCnt(happyActivityOption.getLikesCnt() + 1);
        happyActivityOptionMapper.updateById(happyActivityOption);
    }

    @Override
    public void substructJoinCnt(Long activityId, Integer numCnt) {
        HappyActivity happyActivity = this.baseMapper.selectById(activityId);
        if(ObjectUtil.isNotEmpty(happyActivity)){
            happyActivity.setJoinCnt(happyActivity.getJoinCnt() -numCnt);
            this.baseMapper.updateById(happyActivity);
        }
    }



    // 处理无需支付订单
    private void processNoPayOrder(HappyActivityOrder order, Long orderId) {
@@ -622,7 +731,7 @@

        LambdaQueryWrapper<HappyActivityOrder> happyActivityOrderLambdaQueryWrapper = new LambdaQueryWrapper<>();
        happyActivityOrderLambdaQueryWrapper.eq(HappyActivityOrder::getMemberId, memberId);
        if(ObjectUtil.isNotEmpty(dto.getState())){
        if(ObjectUtil.isNotEmpty(dto.getState()) && dto.getState() != 0){
            happyActivityOrderLambdaQueryWrapper.eq(HappyActivityOrder::getState, dto.getState());
        }
        happyActivityOrderLambdaQueryWrapper.eq(HappyActivityOrder::getDeleteFlag, StateUpDownEnum.DOWN.getCode());
@@ -636,6 +745,7 @@
            List<HappyActivity> happyActivities = this.baseMapper.selectList(
                    new LambdaQueryWrapper<HappyActivity>()
                            .select(
                                    HappyActivity::getId,
                                    HappyActivity::getCategoryId,
                                    HappyActivity::getName,
                                    HappyActivity::getStartTime,
@@ -847,12 +957,64 @@
    }

    @Override
    public void overtimeJob() {
        List<HappyActivityOrder> happyActivityOrders = happyActivityOrderMapper.selectList(
                new LambdaQueryWrapper<HappyActivityOrder>()
                        .eq(HappyActivityOrder::getState, StateUpDownEnum.ORDER_STATE_WAIT_PAY.getCode())
                        .lt(HappyActivityOrder::getFailTime, new Date())
        );
        if(CollUtil.isNotEmpty(happyActivityOrders)){
            happyActivityOrders.forEach(happyActivityOrder -> {

                Long activityId = happyActivityOrder.getActivityId();
                Integer numCnt = happyActivityOrder.getNumCnt();
                this.baseMapper.updateHappyActivitySurplusCnt(activityId,numCnt);

                happyActivityOrder.setState(StateUpDownEnum.ORDER_STATE_OVERTIME.getCode());
                happyActivityOrderMapper.updateById(happyActivityOrder);
            });
        }
    }

    @Override
    public FebsResponse addComment(ApiPayOrderAddCommentDto dto) {
        // 获取当前登录用户的ID
        Long memberId = LoginUserUtil.getLoginUser().getId();
        Long orderId = dto.getOrderId();

        HappyActivityOrder happyActivityOrder = happyActivityOrderMapper.selectById(orderId);
        if(StateUpDownEnum.ORDER_STATE_USED.getCode() != happyActivityOrder.getState()){
            throw new FebsException("该订单状态不是已使用状态！");
        }

        happyActivityOrder.setState(StateUpDownEnum.ORDER_STATE_COMMENT.getCode());
        happyActivityOrderMapper.updateById(happyActivityOrder);

        HappyActivity happyActivity = this.baseMapper.selectById(happyActivityOrder.getActivityId());

        HappyActivityComment happyActivityComment = new HappyActivityComment();
        happyActivityComment.setActivityId(happyActivity.getId());
        happyActivityComment.setActivityName(happyActivity.getName());
        happyActivityComment.setMemberId(memberId);
        happyActivityComment.setOrderId(orderId);
        happyActivityComment.setStar(dto.getStar());
        happyActivityComment.setComment(dto.getComment());
        happyActivityComment.setImages(dto.getImages());
        happyActivityCommentMapper.insert(happyActivityComment);

        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public List<ApiActivityCommentVo> commentByActivityId(ApiActivityCommentDto dto) {
        Page<ApiActivityCommentVo> page = new Page<>(dto.getPageNow(), dto.getPageSize());
        return this.baseMapper.selectActivityCommentPage(page,dto);
    }

    @Override
    public FebsResponse voteActivityHot(Long id) {

        ApiVoteActivityHotVo apiVoteActivityHotVo = new ApiVoteActivityHotVo();
        HappyActivity happyActivity = this.baseMapper.selectById(id);
        apiVoteActivityHotVo.setStartTime(happyActivity.getStartTime());
        apiVoteActivityHotVo.setEndTime(happyActivity.getEndTime());

        Integer optionCnt = happyActivityOptionMapper.selectCount(
                new LambdaQueryWrapper<HappyActivityOption>()