raex_back/src/main/java/com/izouma/nineth/service/TradeAuctionService.java

package com.izouma.nineth.service;

import com.izouma.nineth.config.GeneralProperties;
import com.izouma.nineth.config.RedisKeys;
import com.izouma.nineth.domain.TradeAuction;
import com.izouma.nineth.domain.TradeAuctionOrder;
import com.izouma.nineth.domain.TradeAuctionRecord;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.AuctionOrderStatus;
import com.izouma.nineth.enums.TradeAuctionStatus;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.TradeAuctionRepo;
import com.izouma.nineth.utils.JpaUtils;
import com.izouma.nineth.utils.ObjUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.data.domain.Page;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.security.PrivateKey;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

@Service
@AllArgsConstructor
@Slf4j
public class TradeAuctionService {

    private TradeAuctionRepo              tradeAuctionRepo;
    private RedisTemplate<String, Object> redisTemplate;
    private RocketMQTemplate              rocketMQTemplate;
    private GeneralProperties             generalProperties;

    public Page<TradeAuction> all(PageQuery pageQuery) {
        return tradeAuctionRepo
                .findAll(JpaUtils.toSpecification(pageQuery, TradeAuction.class), JpaUtils.toPageRequest(pageQuery));
    }

    public TradeAuction save(TradeAuction record) {
        if (record.getId() != null) {
            TradeAuction orig = tradeAuctionRepo.findById(record.getId()).orElseThrow(new BusinessException("无记录"));
            ObjUtils.merge(orig, record);
            return tradeAuctionRepo.save(orig);
        }
        record.setCurrentEndTime(record.getStartTime());
        record.setCurrentPrice(record.getPrice());
        record.setStatus(TradeAuctionStatus.WAITING);
        BigDecimal result = record.getCurrentPrice().multiply(BigDecimal.valueOf(record.getIncreasePer()))
                .divide(new BigDecimal("100"), 2, RoundingMode.HALF_UP);
        record.setNextPrice(result);
        record.setEarning(result.subtract(record.getPrice()));
        return tradeAuctionRepo.save(record);
    }

//    public void transfer(Long id) {
//        TradeAuctionRecord tradeAuctionRecord = new TradeAuctionRecord();
//        TradeAuction tradeAuction = tradeAuctionRepo.findById(id).orElseThrow(new BusinessException("暂无"));
//        tradeAuction.setStatus(TradeAuctionStatus.WAITING);
//        increaseSale(tr)
//    }

    public synchronized Long increaseStock(Long id, int number) {
        BoundValueOperations<String, Object> ops = redisTemplate.boundValueOps(RedisKeys.AUCTION_STOCK + id);
        if (ops.get() == null) {
            Boolean success = ops.setIfAbsent(Optional.ofNullable(tradeAuctionRepo.getStock(id))
                    .orElse(0), 7, TimeUnit.DAYS);
            log.info("创建redis库存：{}", success);
        }
        Long stock = ops.increment(number);
        rocketMQTemplate.convertAndSend(generalProperties.getUpdateStockTopic(), id);
        return stock;
    }

    public synchronized Integer getStock(Long id) {
        BoundValueOperations<String, Object> ops = redisTemplate.boundValueOps(RedisKeys.AUCTION_STOCK + id);
        Integer stock = (Integer) ops.get();
        if (stock == null) {
            Boolean success = ops.setIfAbsent(Optional.ofNullable(tradeAuctionRepo.getStock(id))
                    .orElse(0), 7, TimeUnit.DAYS);
            log.info("创建redis库存：{}", success);
            return (Integer) ops.get();
        } else {
            return stock;
        }
    }

    public synchronized Long decreaseStock(Long id, int number) {
        return increaseStock(id, -number);
    }

    public synchronized Long increaseSale(Long id, int number) {
        BoundValueOperations<String, Object> ops = redisTemplate.boundValueOps(RedisKeys.COLLECTION_SALE + id);
        if (ops.get() == null) {
            Boolean success = ops.setIfAbsent(Optional.ofNullable(tradeAuctionRepo.getSale(id))
                    .orElse(0), 7, TimeUnit.DAYS);
            log.info("创建redis销量：{}", success);
        }
        Long sale = ops.increment(number);
        redisTemplate.opsForHash().increment(RedisKeys.UPDATE_SALE, id.toString(), 1);
//        rocketMQTemplate.convertAndSend(generalProperties.getUpdateSaleTopic(), id);
        return sale;
    }

    public synchronized Long decreaseSale(Long id, int number) {
        return increaseSale(id, -number);
    }

    //    @Debounce(key = "#id", delay = 500)
    public void syncStock(Long id) {
        Integer stock = (Integer) redisTemplate.opsForValue().get(RedisKeys.COLLECTION_STOCK + id);
        if (stock != null) {
            log.info("同步库存信息{}", id);
            tradeAuctionRepo.updateStock(id, stock);
//            cacheService.clearCollection(id);
        }
    }

    //    @Debounce(key = "#id", delay = 500)
    public void syncSale(Long id) {
        Integer sale = (Integer) redisTemplate.opsForValue().get(RedisKeys.COLLECTION_SALE + id);
        if (sale != null) {
            log.info("同步销量信息{}", id);
            tradeAuctionRepo.updateSale(id, sale);
//            cacheService.clearCollection(id);
        }
    }

    @Scheduled(fixedRate = 6000)
    public void batchStartAuction() {
        List<TradeAuctionStatus> tradeAuctionStatuses = new ArrayList<>();
        tradeAuctionStatuses.add(TradeAuctionStatus.WAITING);
        tradeAuctionStatuses.add(TradeAuctionStatus.NOTSTARTED);
        List<TradeAuction> tradeAuctions = tradeAuctionRepo
                .findByStatusInAndCurrentEndTimeBefore(tradeAuctionStatuses,
                        LocalDateTime.now().plusMinutes(1));
        tradeAuctions.parallelStream().forEach(o -> {
            try {
                TradeAuction auction = tradeAuctionRepo.findById(o.getId())
                        .orElseThrow(new BusinessException("订单不存在"));
                if (auction.getStatus() == TradeAuctionStatus.WAITING || auction
                        .getStatus() == TradeAuctionStatus.NOTSTARTED) {
                    start(auction);
                }
            } catch (Exception e) {
                log.error("取消易拍订单错误 " + o.getId(), e);
            }
        });
    }

    public void start(TradeAuction tradeAuction) {
        tradeAuction.setStatus(TradeAuctionStatus.ONGOING);
        tradeAuctionRepo.save(tradeAuction);

        increaseStock(tradeAuction.getId(), 1);
    }
}