auction/lot/src/main/java/cn/hobbystocks/auc/service/impl/AuctionServiceImpl.java

package cn.hobbystocks.auc.service.impl;

import cn.hobbystocks.auc.cache.CacheMap;
import cn.hobbystocks.auc.service.ILotService;
import cn.hobbystocks.auc.common.constant.Constants;
import cn.hobbystocks.auc.common.core.redis.RedisCache;
import cn.hobbystocks.auc.common.core.text.Convert;
import cn.hobbystocks.auc.common.utils.DateUtils;
import cn.hobbystocks.auc.domain.Auction;
import cn.hobbystocks.auc.mapper.AuctionMapper;
import cn.hobbystocks.auc.service.IAuctionService;
import cn.hobbystocks.auc.vo.AuctionVO;
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.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.DefaultTransactionDefinition;

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

@Service
@Slf4j
public class AuctionServiceImpl extends ServiceImpl<AuctionMapper,Auction> implements IAuctionService
{

    @Autowired
    private ILotService lotService;
    @Autowired
    private RedisCache redisCache;
    @Resource
    private DataSourceTransactionManager transactionManager;
    @Autowired(required = false)
    private CacheMap cacheMap;

    @Override
    public Auction selectAuctionById(Long id)
    {
        return getBaseMapper().selectAuctionById(id);
    }

    @Override
    public Auction selectAuctionByNo(String no) {
        return getBaseMapper().selectAuctionByNo(no);
    }

    @Override
    public List<Auction> selectAuctionList(Auction auction) {
        IPage<Auction> page=new Page<>(auction.getPageNum(),auction.getPageSize());
        return getBaseMapper().selectAuctionList(page,auction);
    }

    @Override
    public int insertAuction(Auction auction) {
        auction.setCreateTime(DateUtils.getNowDate());
        return getBaseMapper().insertAuction(auction);
    }

    @Override
    public int updateAuction(Auction auction) {
        auction.setUpdateTime(DateUtils.getNowDate());
        return getBaseMapper().updateAuction(auction);
    }

    @Override
    public int deleteAuctionByIds(String ids)
    {
        return getBaseMapper().deleteAuctionByIds(Convert.toLongArray(ids));
    }

    @Override
    public int deleteAuctionById(Long id)
    {
        return getBaseMapper().deleteAuctionById(id);
    }

    @Override
    @Transactional(isolation = Isolation.READ_COMMITTED, rollbackFor = Exception.class)
    public void pubAuction(AuctionVO auction) {
        if (Objects.equals(Constants.PUB_STATUS_PUBLISHED, auction.getPubStatus())) {
            auction.setPubTime(new Date());
            auction.setStatus(Constants.LOT_STATUS_WAITING);
            Auction db = getBaseMapper().selectAuctionById(auction.getId());
            redisCache.setCacheObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()), db);
        }else if (Objects.equals(Constants.PUB_STATUS_CANCEL_PUBLISHED, auction.getPubStatus())){
            auction.setUpdateTime(new Date());
            auction.setStatus(Constants.LOT_STATUS_CANCELLED);
            redisCache.deleteObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()));
        }
        getBaseMapper().updateAuction(auction);
        if (auction.getPubLots()) {
            lotService.pubLots(auction);
        }
    }

    @Override
    public void auctionLive() {
        getBaseMapper().selectNeedStart().forEach(auction -> updateAuction(auction, Constants.GROUP_STATUS_STARTING));
        getBaseMapper().selectNeedEnd().forEach(auction -> updateAuction(auction, Constants.GROUP_STATUS_FINISH));
    }

    @Override
    public List<Auction> live() {
        return getBaseMapper().selectLive();
    }

    private void updateAuction(Auction auction, String status) {
        auction.setUpdateTime(new Date());
        auction.setStatus(status);
        TransactionStatus transaction = null;
        try {
            DefaultTransactionDefinition def = new DefaultTransactionDefinition();
            def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
            def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
            transaction = transactionManager.getTransaction(def);
            getBaseMapper().updateAuction(auction);
            if (status.equals(Constants.GROUP_STATUS_FINISH)) {
                redisCache.deleteObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()));
                redisCache.deleteObject(String.format(Constants.REDIS_MAP_AUC_LOT_TEMPLATE, auction.getId()));
                cacheMap.end(auction.getId());
            }else {
                redisCache.setCacheObject(String.format(Constants.REDIS_AUC_TEMPLATE, auction.getId()), auction);
            }
            transactionManager.commit(transaction);
        }catch (Exception e){
            log.error("auction end error, {}", auction, e);
            if(Objects.nonNull(transaction)){
                transactionManager.rollback(transaction);
            }
        }
    }
}