外网部署参数修改

admin

2021-01-18 d6df4ca797ee1c6ce8fa78768f5425f187734bd9

 service-lucky/src/main/java/com/ks/lucky/service/impl/LuckyActivityManager.java

@@ -1,16 +1,26 @@
package com.ks.lucky.service.impl;

import com.ks.lucky.exception.LuckyActivityException;
import com.ks.lucky.exception.LuckyMQException;
import com.ks.lucky.mapper.LuckyActivityMapper;
import com.ks.lucky.pojo.DO.LuckyActivity;
import com.ks.lucky.pojo.DO.LuckyActivityOpenInfo;
import com.ks.lucky.pojo.DO.*;
import com.ks.lucky.pojo.DTO.ActivityMQMsg;
import com.ks.lucky.pojo.DTO.mq.ActivityStateChangeMsgDTO;
import com.ks.lucky.service.LuckyActivityImageService;
import com.ks.lucky.service.LuckyMQService;
import com.ks.lucky.util.LoggerUtil;
import com.ks.lucky.util.annotation.RedisCache;
import com.ks.lucky.util.annotation.RedisCacheEvict;
import com.ks.lucky.util.mq.CMQManager;
import com.ks.lucky.util.mq.LuckyMQFactory;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;


@Component
@@ -21,6 +31,55 @@

    @Resource
    private LuckyActivityOpenInfoManager luckyActivityOpenInfoManager;

    @Resource
    private LuckyMQService luckyMQService;
    @Resource
    private LuckyActivityImageService luckyActivityImageService;
    @Resource
    private LuckyActivitySponsorInfoManager luckyActivitySponsorInfoManager;
    @Resource
    private LuckyActivityAwardManager luckyActivityAwardManager;


    @RedisCache(cate = "activity", key = "'activity-detail-'+#id", second = 3600)
    public LuckyActivity getActivityDetail(Long id) {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKey(id);
        if (activity == null) {
            return null;
        }

        //加载图片信息
        List<LuckyActivityImage> bannerList = luckyActivityImageService.listByActivityId(id, LuckyActivityImage.LuckyImageType.banner);
        activity.setBannerList(bannerList);

        //加载开奖信息
        LuckyActivityOpenInfo openInfo = luckyActivityOpenInfoManager.getOpenInfo(activity.getId());
        activity.setOpenInfo(openInfo);

        //加载赞助信息
        LuckyActivitySponsorInfo sponsorInfo = luckyActivitySponsorInfoManager.getSponsorInfo(activity.getId());
        if (sponsorInfo != null) {
            sponsorInfo = luckyActivitySponsorInfoManager.getSponsorInfoDetail(sponsorInfo.getId());
        }
        activity.setSponsorInfo(sponsorInfo);


        //加载奖项信息
        List<LuckyActivityAwards> awardsList = luckyActivityAwardManager.getAwardList(activity.getId());
        List<LuckyActivityAwards> awardsDetailList = new ArrayList<>();
        if (awardsList != null) {
            for (LuckyActivityAwards awards : awardsList) {
                awards = luckyActivityAwardManager.getAwardDetail(awards.getId());
                if (awards != null) {
                    awardsDetailList.add(awards);
                }
            }
        }
        activity.setAwardsList(awardsDetailList);

        return activity;
    }


    /**
@@ -36,12 +95,9 @@
            throw new LuckyActivityException(LuckyActivityException.CODE_NOT_EXIST, "活动不存在");
        }

        if (activity.getState() == LuckyActivity.STATE_NOT_STARTED) {
            throw new LuckyActivityException(1, "活动还未开始");
        }

        if (activity.getState() == LuckyActivity.STATE_FINISH || activity.getState() == LuckyActivity.STATE_OPENED) {
            throw new LuckyActivityException(1, "活动已经结束");
        if (activity.getState() != LuckyActivity.STATE_STARTED) {
            throw new LuckyActivityException(1, "活动不可参与");
        }

        if (activity.getCurrentPersonCount() >= activity.getMaxPersonCount()) {
@@ -51,6 +107,23 @@
        return true;
    }


    /**
     * 是否可以更改活动内容
     *
     * @param activityId
     * @return
     */
    public boolean canUpdate(Long activityId) {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKey(activityId);
        if (activity != null) {
            if (activity.getState() == LuckyActivity.STATE_VERIFY_REJECT || activity.getState() == LuckyActivity.STATE_NOT_SUBMIT_VERIFY) {
                return true;
            }
        }
        return false;
    }

    /**
     * 添加参与数
     *
@@ -58,6 +131,7 @@
     * @param count
     * @throws LuckyActivityException
     */
    @RedisCacheEvict(cate = "activity", key = "'activity-detail-'+#activityId")
    @Transactional(rollbackFor = Exception.class)
    public void addJoinCount(Long activityId, int count) throws LuckyActivityException {
        LuckyActivity luckyActivity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
@@ -75,7 +149,7 @@
        update.setId(activityId);
        update.setCurrentPersonCount(currentCount + count);
        update.setUpdateTime(new Date());
        luckyActivityMapper.updateByPrimaryKeySelective(update);
        updateSelectiveByPrimaryKey(update);
        if (update.getCurrentPersonCount().intValue() >= openInfo.getMinPersonCount() && currentCount < openInfo.getMinPersonCount()) {
            //达到最低开奖人数
            CMQManager.getInstance().addActivityMsg(new ActivityMQMsg(activityId, ActivityMQMsg.TYPE_REACH_MIN_PERSON, new Date()));
@@ -93,7 +167,9 @@
     *
     * @param activityId
     */
    public void startUpActivity(Long activityId) throws LuckyActivityException {
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    @RedisCacheEvict(cate = "activity", key = "'activity-detail-'+#activityId")
    public void startUpActivity(Long activityId) throws LuckyActivityException, LuckyMQException {
        LuckyActivity luckyActivity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        if (luckyActivity == null) {
            throw new LuckyActivityException(LuckyActivityException.CODE_NOT_EXIST, "活动不存在");
@@ -105,6 +181,80 @@

        //启动活动
        setState(activityId, LuckyActivity.STATE_STARTED, "已经启动");
        //设置实际开始时间
        LuckyActivity update = new LuckyActivity();
        update.setId(activityId);
        update.setActualStartTime(new Date());
        update.setUpdateTime(new Date());
        updateSelectiveByPrimaryKey(update);

        //有预计结束时间
        if (luckyActivity.getPreFinishTime() != null) {
            //添加结束消息
            LuckyMQ mq = LuckyMQFactory.createFinishActivity(luckyActivity);
            luckyMQService.addMQ(mq);
        }

        //尝试删除消息
        try {
            LuckyMQ mq = LuckyMQFactory.createStartUpActivity(luckyActivity);
            luckyMQService.removeUnSendMsg(mq.getTaskId());
        } catch (LuckyMQException e) {
            e.printStackTrace();
        }

        LoggerUtil.activityLogger.info("活动启动成功:activityId-{}", activityId);
    }


    /**
     * 结束活动
     *
     * @param activityId
     * @param force      是否强制结束
     * @param remarks
     */
    @RedisCacheEvict(cate = "activity", key = "'activity-detail-'+#activityId")
    @Transactional(rollbackFor = Exception.class)
    public void finishActivity(Long activityId, boolean force, String remarks) throws LuckyActivityException, LuckyMQException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        if (activity.getState() != LuckyActivity.STATE_STARTED) {
            throw new LuckyActivityException(1, "活动未处于已开始状态");
        }

        //设置活动处于强制结束状态
        if (force) {
            setState(activityId, LuckyActivity.STATE_FOUCE_FINISH, remarks);
        } else {
            setState(activityId, LuckyActivity.STATE_FINISH, remarks);
        }
        LuckyActivity update = new LuckyActivity();
        update.setId(activityId);
        update.setActualFinishTime(new Date());
        update.setUpdateTime(new Date());
        updateSelectiveByPrimaryKey(update);

        activity.setActualFinishTime(update.getActualFinishTime());
        //强制结束的不开奖
        if (!force) {
            //添加开奖消息
            LuckyActivityOpenInfo openInfo = luckyActivityOpenInfoManager.getOpenInfo(activityId);
            Date openTime = openInfo.getPreOpenTime();
            if (openTime == null) {
                openTime = new Date();
            }
            LuckyMQ mq = LuckyMQFactory.createOpenActivity(activityId, openTime);
            luckyMQService.addMQ(mq);
        }
        //尝试删除消息
        try {
            LuckyMQ mq1 = LuckyMQFactory.createFinishActivity(activity);
            luckyMQService.removeUnSendMsg(mq1.getTaskId());
        } catch (LuckyMQException e) {
            e.printStackTrace();
        }

        LoggerUtil.activityLogger.info("活动成功结束:activityId-{} force-{} remarks-{}", activityId, force, remarks);
    }


@@ -126,12 +276,24 @@
     * @param state
     * @param stateRemarks
     */
    @RedisCacheEvict(cate = "activity", key = "'activity-detail-'+#activityId")
    @Transactional(rollbackFor = Exception.class)
    public void setState(Long activityId, int state, String stateRemarks) {
        LuckyActivity activity = new LuckyActivity();
        activity.setId(activityId);
        activity.setState(state);
        activity.setStateRemarks(stateRemarks);
        activity.setUpdateTime(new Date());
        updateSelectiveByPrimaryKey(activity);
        CMQManager.getInstance().publishActivityStateChangeMsg(new ActivityStateChangeMsgDTO(activityId, state, stateRemarks, activity.getUpdateTime()));
        LoggerUtil.activityLogger.info("活动状态更改：activityId-{}  state-{} stateRemarks-{}", activityId, state, stateRemarks);
    }

    @RedisCacheEvict(cate = "activity", key = "'activity-detail-'+#activity.id")
    public void updateSelectiveByPrimaryKey(LuckyActivity activity) {
        if (activity.getUpdateTime() == null) {
            activity.setUpdateTime(new Date());
        }
        luckyActivityMapper.updateByPrimaryKeySelective(activity);
    }