feat(mall): 增加会员列表核销员设置功能并优化相关页面

Administrator

8 days ago 7966b494ddea2c27ecec6ed031521cb889ab19f5

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

@@ -7,15 +7,20 @@
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.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.pay.model.BrandWCPayRequestData;
import cc.mrbird.febs.pay.service.IXcxPayService;
import cc.mrbird.febs.rabbit.producter.AgentProducer;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateTime;
@@ -25,6 +30,7 @@
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;
@@ -35,6 +41,7 @@
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@Slf4j
@@ -51,6 +58,8 @@
    private final HappyActivityOrderItemMapper happyActivityOrderItemMapper;
    private final IXcxPayService iXcxPayService;
    private final IApiMallMemberWalletService iApiMallMemberWalletService;
    private final HappyActivityCategoryMapper happyActivityCategoryMapper;
    private final AgentProducer agentProducer;

    @Override
    public FebsResponse activityList(ApiActivityInfoDto dto) {
@@ -68,7 +77,6 @@
            // 查询关注点赞转发记录，筛选出关注活动类型且未删除的关注记录，并按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())
@@ -124,7 +132,6 @@
        HappyActivity happyActivity = this.baseMapper.selectOne(
                new LambdaQueryWrapper<HappyActivity>()
                        .eq(HappyActivity::getId, dto.getId())
                        .eq(HappyActivity::getType, dto.getType())
                        .eq(HappyActivity::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                        .ne(HappyActivity::getState, StateUpDownEnum.ACTIVITY_STATE_NOT_START.getCode())
        );
@@ -143,6 +150,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();
@@ -150,6 +165,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);
    }

@@ -225,6 +278,12 @@
        if(StateUpDownEnum.ACTIVITY_TYPE_VOTE.getCode() != happyActivity.getType()){
            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("活动已结束");
        }

        HappyActivityOption happyActivityOption = happyActivityOptionMapper.selectById(sourceOptionId);
        if (null == happyActivityOption) {
@@ -238,7 +297,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()))
        );
@@ -260,7 +318,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)
@@ -282,14 +340,81 @@
    }

    @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
    public FebsResponse operateRegister(ApiOperateRegisterActivityDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();
        return null;

        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("您已经报名过了");
        }

        Integer optionCnt = happyActivityOptionMapper.selectCount(
                new LambdaQueryWrapper<HappyActivityOption>()
                        .eq(HappyActivityOption::getActivityId, dto.getActivityId())
                        .eq(HappyActivityOption::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
        );

        HappyActivityOption happyActivityOption = new HappyActivityOption();
        BeanUtil.copyProperties(dto, happyActivityOption);
        happyActivityOption.setOrderCnt(optionCnt + 1);
        happyActivityOption.setMemberId(memberId);
        happyActivityOption.setOptionName(dto.getRealName());
        happyActivityOptionMapper.insert(happyActivityOption);
        return new FebsResponse().success().message("报名成功");
    }

    @Override
    public FebsResponse addConnect(ApiOperateRegisterUserDto dto) {
        Long memberId = LoginUserUtil.getLoginUser().getId();

        List<HappyActivityConnect> happyActivityConnects = happyActivityConnectMapper.selectList(
                new LambdaQueryWrapper<HappyActivityConnect>()
                        .eq(HappyActivityConnect::getMemberId, memberId)
                        .eq(HappyActivityConnect::getName, dto.getName())
        );
        if(CollUtil.isNotEmpty(happyActivityConnects)){
            throw new FebsException("已经添加过该联系人");
        }

        HappyActivityConnect happyActivityConnect = new HappyActivityConnect();
        happyActivityConnect.setMemberId(memberId);
@@ -358,6 +483,12 @@
        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();
@@ -492,6 +623,8 @@
        }
    }



    // 处理无需支付订单
    private void processNoPayOrder(HappyActivityOrder order, Long orderId) {
        updateOrderState(order, StateUpDownEnum.PAY_METHOD_NO_PAY.getCode(), StateUpDownEnum.PAY_STATE_PAY_SUCCESS.getCode(),StateUpDownEnum.ORDER_STATE_WAIT_USE.getCode());
@@ -552,6 +685,265 @@
        return happyActivityOrder.getOrderNo();
    }

    @Override
    public FebsResponse orderList(ApiActivityOrderListDto dto) {

        // 获取当前登录用户的ID
        Long memberId = LoginUserUtil.getLoginUser().getId();

        ArrayList<ApiActivityOrderListVo> apiActivityOrderListVos = new ArrayList<>();

        LambdaQueryWrapper<HappyActivityOrder> happyActivityOrderLambdaQueryWrapper = new LambdaQueryWrapper<>();
        happyActivityOrderLambdaQueryWrapper.eq(HappyActivityOrder::getMemberId, memberId);
        if(ObjectUtil.isNotEmpty(dto.getState())){
            happyActivityOrderLambdaQueryWrapper.eq(HappyActivityOrder::getState, dto.getState());
        }
        happyActivityOrderLambdaQueryWrapper.eq(HappyActivityOrder::getDeleteFlag, StateUpDownEnum.DOWN.getCode());
        happyActivityOrderLambdaQueryWrapper.orderByDesc(HappyActivityOrder::getCreatedTime);
        Page<HappyActivityOrder> page = new Page<>(dto.getPageNum(), dto.getPageSize());
        Page<HappyActivityOrder> voteActivityPage = happyActivityOrderMapper.selectPage(page, happyActivityOrderLambdaQueryWrapper);

        List<HappyActivityOrder> records = voteActivityPage.getRecords();
        if(CollUtil.isNotEmpty(records)){
            Set<Long> activityIds = records.stream().map(HappyActivityOrder::getActivityId).collect(Collectors.toSet());
            List<HappyActivity> happyActivities = this.baseMapper.selectList(
                    new LambdaQueryWrapper<HappyActivity>()
                            .select(
                                    HappyActivity::getCategoryId,
                                    HappyActivity::getName,
                                    HappyActivity::getStartTime,
                                    HappyActivity::getEndTime,
                                    HappyActivity::getAddress)
                            .in(HappyActivity::getId, activityIds)
            );
            Map<Long, HappyActivity> activityMap = happyActivities.stream().collect(Collectors.toMap(HappyActivity::getId, Function.identity()));

            Set<Long> categoryIds = happyActivities.stream().map(HappyActivity::getCategoryId).collect(Collectors.toSet());
            //stream流操作categoryIds得到一个Map<categoryId,HappyActivityCategory>的map对象
            List<HappyActivityCategory> happyActivityCategories = happyActivityCategoryMapper.selectList(
                    new LambdaQueryWrapper<HappyActivityCategory>()
                            .select(
                                    HappyActivityCategory::getId,
                                    HappyActivityCategory::getName)
                            .in(HappyActivityCategory::getId,categoryIds)
            );
            Map<Long, HappyActivityCategory> categoryMap = happyActivityCategories.stream().collect(Collectors.toMap(HappyActivityCategory::getId, Function.identity()));

            for(HappyActivityOrder happyActivityOrder : records){
                ApiActivityOrderListVo apiActivityOrderListVo = new ApiActivityOrderListVo();
                BeanUtil.copyProperties(happyActivityOrder, apiActivityOrderListVo);

                apiActivityOrderListVo.setActivityName(activityMap.get(happyActivityOrder.getActivityId()).getName());
                apiActivityOrderListVo.setStartTime(activityMap.get(happyActivityOrder.getActivityId()).getStartTime());
                apiActivityOrderListVo.setEndTime(activityMap.get(happyActivityOrder.getActivityId()).getEndTime());
                apiActivityOrderListVo.setAddress(activityMap.get(happyActivityOrder.getActivityId()).getAddress());
                apiActivityOrderListVo.setCategoryName(categoryMap.get(activityMap.get(happyActivityOrder.getActivityId()).getCategoryId()).getName());

                apiActivityOrderListVos.add(apiActivityOrderListVo);
            }
        }

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

    @Override
    public FebsResponse orderInfo(Long id) {
        // 获取当前登录用户的ID
        Long memberId = LoginUserUtil.getLoginUser().getId();
        ArrayList<ApiActivityOrderInfoVo> apiActivityOrderInfoVos = new ArrayList<>();

        HappyActivityOrder happyActivityOrder = happyActivityOrderMapper.selectById(id);

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

        List<HappyActivityOrderItem> happyActivityOrderItems = happyActivityOrderItemMapper.selectList(
                new LambdaQueryWrapper<HappyActivityOrderItem>()
                        .eq(HappyActivityOrderItem::getOrderId, happyActivityOrder.getActivityId())
                .eq(HappyActivityOrderItem::getMemberId, memberId)
        );
        if(CollUtil.isNotEmpty(happyActivityOrderItems)){
            for(HappyActivityOrderItem happyActivityOrderItem : happyActivityOrderItems){
                ApiActivityOrderInfoVo apiActivityOrderInfoVo = new ApiActivityOrderInfoVo();
                BeanUtil.copyProperties(happyActivityOrderItem, apiActivityOrderInfoVo);

                apiActivityOrderInfoVo.setOrderState(happyActivityOrder.getState());

                apiActivityOrderInfoVo.setActivityName(happyActivity.getName());
                apiActivityOrderInfoVo.setActivityStartTime(happyActivity.getStartTime());
                apiActivityOrderInfoVo.setActivityEndTime(happyActivity.getEndTime());
                apiActivityOrderInfoVo.setActivityAddress(happyActivity.getAddress());

                apiActivityOrderInfoVos.add(apiActivityOrderInfoVo);
            }
        }


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

    @Override
    public FebsResponse orderDelete(Long id) {
        // 获取当前登录用户的ID
        Long memberId = LoginUserUtil.getLoginUser().getId();

        List<HappyActivityOrder> happyActivityOrders = happyActivityOrderMapper.selectList(
                new LambdaQueryWrapper<HappyActivityOrder>()
                        .eq(HappyActivityOrder::getId, id)
                        .eq(HappyActivityOrder::getMemberId, memberId)
        );
        if(CollUtil.isNotEmpty(happyActivityOrders)){
            happyActivityOrders.forEach(happyActivityOrder -> {
                happyActivityOrder.setDeleteFlag(StateUpDownEnum.UP.getCode());
                happyActivityOrderMapper.updateById(happyActivityOrder);
            });
        }
        return new FebsResponse().success();
    }

    @Override
    public void activityEnd() {
        Date date = new Date();
        List<HappyActivity> happyActivities = this.baseMapper.selectList(
                new LambdaQueryWrapper<HappyActivity>()
                        .eq(HappyActivity::getState, StateUpDownEnum.ACTIVITY_STATE_ENROLLING.getCode())
                        .le(HappyActivity::getEndTime, date)
        );
        if(CollUtil.isEmpty(happyActivities)){
            return;
        }
        happyActivities.forEach(happyActivity -> {
            happyActivity.setState(StateUpDownEnum.ACTIVITY_STATE_END.getCode());
            this.baseMapper.updateById(happyActivity);
        });
    }

    /**
     * 当活动即将开始时自动更新活动状态
     * 此方法旨在查询所有即将开始的活动，并将它们的状态更新为报名进行中
     */
    @Override
    public void activityStart() {
        // 获取当前日期和时间
        DateTime date = DateUtil.date();

        // 查询所有状态为未开始且当前时间在活动开始时间结束时间之间的活动
        List<HappyActivity> happyActivities = this.baseMapper.selectList(
                new LambdaQueryWrapper<HappyActivity>()
                        .eq(HappyActivity::getState, StateUpDownEnum.ACTIVITY_STATE_NOT_START.getCode())
                        .le(HappyActivity::getStartTime, date)
                        .ge(HappyActivity::getEndTime, date)
        );

        // 如果没有找到任何符合条件的活动，则直接返回
        if(CollUtil.isEmpty(happyActivities)){
            return;
        }

        // 遍历每个符合条件的活动，将其状态更新为报名进行中，并保存更新
        happyActivities.forEach(happyActivity -> {
            happyActivity.setState(StateUpDownEnum.ACTIVITY_STATE_ENROLLING.getCode());
            this.baseMapper.updateById(happyActivity);
        });
    }

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

        MallMember mallMember = mallMemberMapper.selectById(memberId);

        if(StateUpDownEnum.UP.getCode() != mallMember.getCheckOrder()){
            throw new FebsException("您不是核销员！");
        }

        String orderItemCode = dto.getOrderItemCode();

        HappyActivityOrderItem happyActivityOrderItem = happyActivityOrderItemMapper.selectOne(
                new LambdaQueryWrapper<HappyActivityOrderItem>()
                        .eq(HappyActivityOrderItem::getCode, orderItemCode)
                        .eq(HappyActivityOrderItem::getState, StateUpDownEnum.DOWN.getCode())
                .last("limit 1")
        );
        if(happyActivityOrderItem != null){
            happyActivityOrderItem.setState(StateUpDownEnum.UP.getCode());
            happyActivityOrderItem.setTransferItemId(memberId);
            happyActivityOrderItemMapper.updateById(happyActivityOrderItem);

            agentProducer.sendCheckActivityItem(happyActivityOrderItem.getOrderId());

            HappyActivity happyActivity = this.baseMapper.selectById(happyActivityOrderItem.getActivityId());
            ApiCheckOrderVo apiCheckOrderVo = new ApiCheckOrderVo();
            apiCheckOrderVo.setActivityName(happyActivity.getName());
            apiCheckOrderVo.setActivityStartTime(happyActivity.getStartTime());
            apiCheckOrderVo.setActivityEndTime(happyActivity.getEndTime());
            apiCheckOrderVo.setActivityAddress(happyActivity.getAddress());
            apiCheckOrderVo.setCode(happyActivityOrderItem.getCode());
            apiCheckOrderVo.setName(happyActivityOrderItem.getName());
            apiCheckOrderVo.setPhone(happyActivityOrderItem.getPhone());
            apiCheckOrderVo.setPrice(happyActivityOrderItem.getPrice());

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

        return new FebsResponse().fail().message("核销失败！");
    }

    /**
     * 检查活动订单项的状态
     * 当指定订单的所有活动订单项都不处于"未使用"状态时，将订单状态更新为"已使用"
     *
     * @param orderId 订单ID，用于查询活动订单项和订单信息
     */
    @Override
    public void checkActivityItem(Long orderId) {
        // 查询指定订单ID的活动订单项数量，且状态为"未使用"
        Integer integer = happyActivityOrderItemMapper.selectCount(
                new LambdaQueryWrapper<HappyActivityOrderItem>()
                        .eq(HappyActivityOrderItem::getOrderId, orderId)
                        .eq(HappyActivityOrderItem::getState, StateUpDownEnum.DOWN.getCode())
        );
        // 如果没有找到任何未使用的活动订单项
        if(0 == integer){
            // 根据订单ID查询订单信息
            HappyActivityOrder happyActivityOrder = happyActivityOrderMapper.selectById(orderId);
            if(happyActivityOrder == null){
                return;
            }
            // 更新订单状态为"已使用"
            happyActivityOrder.setState(StateUpDownEnum.ORDER_STATE_USED.getCode());
            // 保存更新后的订单信息
            happyActivityOrderMapper.updateById(happyActivityOrder);
        }
        // 结束方法执行
        return;
    }

    @Override
    public FebsResponse voteActivityHot(Long id) {

        ApiVoteActivityHotVo apiVoteActivityHotVo = new ApiVoteActivityHotVo();

        Integer optionCnt = happyActivityOptionMapper.selectCount(
                new LambdaQueryWrapper<HappyActivityOption>()
                        .eq(HappyActivityOption::getActivityId, id)
                        .eq(HappyActivityOption::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
                        .eq(HappyActivityOption::getState, StateUpDownEnum.VOTE_OPTION_STATE_AUDIT_SUCCESS.getCode())
        );
        apiVoteActivityHotVo.setOptionCnt(optionCnt);

        Integer followVoteCnt = happyFollowMapper.selectCount(
                new LambdaQueryWrapper<HappyFollow>()
                        .eq(HappyFollow::getSourceType, StateUpDownEnum.SOURCE_TYPE_ACTIVITY.getCode())
                        .eq(HappyFollow::getSourceId, id)
                        .eq(HappyFollow::getType, StateUpDownEnum.VOTE.getCode())
                        .eq(HappyFollow::getDeleteFlag, StateUpDownEnum.DOWN.getCode())
        );
        apiVoteActivityHotVo.setFollowVoteCnt(followVoteCnt);

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


    public static void main(String[] args) {
        Date date = new Date();