DayLucky.git - Gitblit

package com.ks.lucky.service.impl.remote;
 
import com.ks.app.exception.AppException;
import com.ks.lib.common.exception.ParamsException;
import com.ks.lucky.exception.LuckyActivityException;
import com.ks.lucky.exception.LuckyMQException;
import com.ks.lucky.mapper.LuckyActivityMapper;
import com.ks.lucky.pojo.DO.*;
import com.ks.lucky.query.ActivityDaoQuery;
import com.ks.lucky.remote.service.LuckyActivityService;
import com.ks.lucky.service.LuckyMQService;
import com.ks.lucky.service.impl.*;
import com.ks.lucky.util.mq.LuckyMQFactory;
import org.apache.dubbo.config.annotation.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
 
import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
 
@Service(version = "1.0")
public class LuckyActivityServiceImpl implements LuckyActivityService {
 
    @Resource
    private LuckyActivityMapper luckyActivityMapper;
 
    @Resource
    private LuckyActivityManager luckyActivityManager;
 
    @Resource
    private LuckyActivityOpenInfoManager luckyActivityOpenInfoManager;
 
    @Resource
    private LuckyActivitySponsorInfoManager luckyActivitySponsorInfoManager;
 
    @Resource
    private LuckyActivityAwardManager luckyActivityAwardManager;
 
    @Resource
    private AppManager appManager;
 
    @Resource
    private LuckyMQService luckyMQService;
 
    private Long getAppId(String appKey) throws AppException {
        return appManager.getAppId(appKey);
    }
 
    private void notNull(LuckyActivity activity) throws LuckyActivityException {
        if (activity == null) {
            throw new LuckyActivityException(LuckyActivityException.CODE_NOT_EXIST, "活动不存在");
        }
    }
 
    @Override
    public List<LuckyActivity> getActivityList(String appKey, Long sponsorId, List<Integer> stateList, String key, int page, int pageSize) {
        ActivityDaoQuery query = new ActivityDaoQuery();
        query.stateList = stateList;
        query.key = key;
        query.sponsorId = sponsorId;
 
        try {
            query.appId = getAppId(appKey);
        } catch (AppException e) {
            return null;
        }
        query.start = (page - 1) * pageSize;
        query.count = pageSize;
        query.sort = "start_time desc";
        return luckyActivityMapper.list(query);
    }
 
    @Override
    public long countActivity(String appKey, Long sponsorId, List<Integer> stateList, String key) {
        ActivityDaoQuery query = new ActivityDaoQuery();
        query.stateList = stateList;
        query.key = key;
        query.sponsorId = sponsorId;
        try {
            query.appId = getAppId(appKey);
        } catch (AppException e) {
            return 0L;
        }
        return luckyActivityMapper.count(query);
    }
 
 
    @Validated
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createActivity(LuckyActivity activity) throws ParamsException, LuckyActivityException {
 
        activity.setState(LuckyActivity.STATE_NOT_SUBMIT_VERIFY);
        activity.setStateRemarks("未提交审核");
 
        if (activity.getCreateTime() == null) {
            activity.setCreateTime(new Date());
        }
 
        luckyActivityMapper.insertSelective(activity);
        return activity.getId();
    }
 
    @Override
    public void submitVerify(Long activityId) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        notNull(activity);
        if (activity.getState() != LuckyActivity.STATE_NOT_SUBMIT_VERIFY && activity.getState() != LuckyActivity.STATE_VERIFY_REJECT) {
            throw new LuckyActivityException(1, "活动未处于审核被拒绝/未提交审核状态");
        }
 
        luckyActivityManager.setState(activityId, LuckyActivity.STATE_WAITING_VERIFY, "等待审核");
    }
 
 
    /**
     * 检查要发布的活动
     *
     * @param activity
     */
    private void checkActivityForPublish(LuckyActivity activity) throws LuckyActivityException {
        notNull(activity);
        if (activity.getStartTime() == null) {
            throw new LuckyActivityException(1, "活动开始时间未设置");
        }
 
        if (activity.getStartTime().getTime() < System.currentTimeMillis()) {
            throw new LuckyActivityException(1, "活动开始时间不能小于当前时间");
        }
 
        if (activity.getFinishTime() != null && activity.getStartTime().getTime() >= activity.getFinishTime().getTime()) {
            throw new LuckyActivityException(1, "活动开始结束时间不能小于开始时间");
        }
 
        //TODO 检查更多参数
 
 
        //检查活动状态
        if (activity.getState() != LuckyActivity.STATE_NOT_PUBLISH) {
            throw new LuckyActivityException(1, "活动已发布");
        }
        //检查开奖信息
        LuckyActivityOpenInfo openInfo = luckyActivityOpenInfoManager.getOpenInfo(activity.getId());
        if (openInfo == null) {
            throw new LuckyActivityException(2, "不存在开奖信息");
        }
 
        LuckyActivitySponsorInfo sponsorInfo = luckyActivitySponsorInfoManager.getSponsorInfo(activity.getId());
        if (sponsorInfo == null) {
            throw new LuckyActivityException(2, "不存在赞助信息");
        }
 
        List<LuckyActivityAwards> awardsList = luckyActivityAwardManager.getAwardList(activity.getId());
        if (awardsList == null || awardsList.size() == 0) {
            throw new LuckyActivityException(2, "不存在奖项信息");
        }
 
 
    }
 
 
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void publishActivity(Long activityId) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        checkActivityForPublish(activity);
 
 
        luckyActivityManager.setState(activityId, LuckyActivity.STATE_NOT_STARTED, "已发布");
 
        //加入代发消息列表
        try {
            luckyMQService.addMQ(LuckyMQFactory.createStartUpActivity(activity));
        } catch (LuckyMQException e) {
            throw new LuckyActivityException(10, "消息投递失败");
        }
    }
 
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void startActivity(Long activityId, String remarks) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        if (activity.getState() != LuckyActivity.STATE_NOT_STARTED) {
            throw new LuckyActivityException(2, "活动尚未处于已发布状态");
        }
 
        luckyActivityManager.startUpActivity(activityId);
 
        //尝试删除消息
        try {
            LuckyMQ mq = LuckyMQFactory.createStartUpActivity(activity);
            luckyMQService.removeUnSendMsg(mq.getTaskId());
        } catch (LuckyMQException e) {
            e.printStackTrace();
        }
 
    }
 
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void verifyActivity(Long activityId, boolean pass, String remarks) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        if (activity.getState() != LuckyActivity.STATE_WAITING_VERIFY) {
            throw new LuckyActivityException(2, "活动尚未处于审核状态");
        }
 
        //审核活动
        //审核通过
        if (pass) {
            luckyActivityManager.setState(activityId, LuckyActivity.STATE_NOT_PUBLISH, remarks);
        } else {
            //审核未通过
            luckyActivityManager.setState(activityId, LuckyActivity.STATE_VERIFY_REJECT, remarks);
        }
 
    }
 
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void forceFinishActivity(Long activityId, String remarks) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        notNull(activity);
 
        if (activity.getState() != LuckyActivity.STATE_STARTED) {
            throw new LuckyActivityException(1, "活动未处于已开始状态");
        }
 
        //设置活动处于强制结束状态
        luckyActivityManager.setState(activityId, LuckyActivity.STATE_FOUCE_FINISH, remarks);
    }
 
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void cancelPublish(Long activityId, String remarks) throws LuckyActivityException {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKeyForUpdate(activityId);
        notNull(activity);
 
        if (activity.getState() != LuckyActivity.STATE_NOT_STARTED) {
            throw new LuckyActivityException(1, "活动未处于已发布状态");
        }
 
        //设置活动为未发布状态
        luckyActivityManager.setState(activityId, LuckyActivity.STATE_NOT_PUBLISH, remarks);
        //删除相关的消息
        LuckyMQ mq = LuckyMQFactory.createStartUpActivity(activity);
 
        try {
            luckyMQService.removeUnSendMsg(mq.getTaskId());
        } catch (LuckyMQException e) {
            throw new LuckyActivityException(2, e.getMsg());
        }
 
    }
 
    @Override
    public LuckyActivity getActivityDetail(Long id) {
        LuckyActivity activity = luckyActivityMapper.selectByPrimaryKey(id);
        if (activity == null) {
            return null;
        }
        //加载开奖信息
        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());
        activity.setAwardsList(awardsList);
 
        return activity;
    }
 
    @Override
    public void updateActivity(LuckyActivity activity) throws LuckyActivityException {
        if (activity.getState() != null) {
            throw new LuckyActivityException(1, "不能更改活动状态");
        }
        activity.setUpdateTime(new Date());
        luckyActivityMapper.updateByPrimaryKeySelective(activity);
    }
 
 
}