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

package com.izouma.nineth.service;

import com.izouma.nineth.annotations.Debounce;
import com.izouma.nineth.config.RedisKeys;
import com.izouma.nineth.domain.Asset;
import com.izouma.nineth.domain.AuctionActivity;
import com.izouma.nineth.domain.Collection;
import com.izouma.nineth.domain.User;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.dto.auction.AuctionInputDTO;
import com.izouma.nineth.enums.AssetStatus;
import com.izouma.nineth.enums.AuctionSource;
import com.izouma.nineth.enums.AuctionStatus;
import com.izouma.nineth.enums.AuctionType;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.AssetRepo;
import com.izouma.nineth.repo.AuctionActivityRepo;
import com.izouma.nineth.repo.UserRepo;
import com.izouma.nineth.utils.JpaUtils;
import com.izouma.nineth.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.env.Environment;
import org.springframework.data.domain.Page;
import org.springframework.data.redis.core.BoundValueOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestBody;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
@AllArgsConstructor
public class AuctionActivityService {

    private final AuctionActivityRepo           auctionActivityRepo;
    private final AssetRepo                     assetRepo;
    private final UserRepo                      userRepo;
    private final PasswordEncoder               passwordEncoder;
    private final RedisTemplate<String, Object> redisTemplate;
    private final CacheService                  cacheService;
    private final TaskScheduler                 taskScheduler;
    private final Environment                   env;

    private final Map<Long, ScheduledFuture<?>> tasks = new HashMap<>();

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

    public AuctionActivity createFromAsset(AuctionInputDTO dto) {
        Asset asset = assetRepo.findById(dto.getAssetId()).orElseThrow(new BusinessException("暂无"));
        AuctionActivity auctionActivity = new AuctionActivity();
        auctionActivity.setAuctionType(AuctionType.NFT);
        auctionActivity.setAssetId(dto.getAssetId());
        auctionActivity.setStatus(AuctionStatus.ONGOING);
        auctionActivity.setBids(0);
        auctionActivity.setCategory(asset.getCategory());
        auctionActivity.setEndTime(LocalDateTime.now().plusDays(5));
        auctionActivity.setDeposit(dto.getDeposit());
        if (Arrays.asList(env.getActiveProfiles()).contains("staging")) {
            auctionActivity.setEndTime(LocalDateTime.now().plusMinutes(5));
        }
        auctionActivity.setDetail(asset.getDetail());
        auctionActivity.setFixedPrice(dto.getFixedPrice());
        auctionActivity.setIncrement(dto.getIncrement());
        auctionActivity.setMinter(asset.getMinter());
        auctionActivity.setPic(asset.getPic());
        auctionActivity.setModel3d(asset.getModel3d());
        auctionActivity.setName(asset.getName());
        auctionActivity.setSeller(asset.getOwner());
        auctionActivity.setSellerId(asset.getOwnerId());
        auctionActivity.setStartTime(LocalDateTime.now());
        auctionActivity.setSource(AuctionSource.TRANSFER);
        auctionActivity.setServiceCharge(5);
        auctionActivity.setRoyalties(10);
        auctionActivity.setStartingPrice(dto.getStartingPrice());
        if (auctionActivity.getFixedPrice() != null) {
            auctionActivity.setHasFixedPrice(true);
        } else {
            auctionActivity.setHasFixedPrice(false);
        }
        return save(auctionActivity, dto.getTradeCode());
    }


    public AuctionActivity save(AuctionActivity record, String tradeCode) {
        if (record.getSource().equals(AuctionSource.OFFICIAL)) {
            record.setStatus(AuctionStatus.NOTSTARTED);
        }
        if (record.getSource().equals(AuctionSource.TRANSFER) & !record.getSellerId().equals(9859L)) {
            User user = userRepo.findById(record.getSellerId()).orElseThrow(new BusinessException("无用户信息"));
            if (!passwordEncoder.matches(tradeCode, user.getTradeCode())) {
                throw new BusinessException("交易密码错误");
            }
        }

        if (record.getAuctionType().equals(AuctionType.NFT) & !record.getSellerId().equals(9859L)) {
            Asset asset = assetRepo.findById(record.getAssetId()).orElseThrow(new BusinessException("未找到该藏品"));
            if (!asset.getOwnerId().equals(SecurityUtils.getAuthenticatedUser().getId())) {
                throw new BusinessException("非本人藏品，无法操作.");
            }
            if (!asset.getStatus().equals(AssetStatus.NORMAL)) {
                throw new BusinessException("藏品状态异常，无法操作.");
            }
            if (asset.isConsignment()) {
                throw new BusinessException("藏品已寄售，取消寄售后再申请拍卖。");
            }
            asset.setStatus(AssetStatus.AUCTIONING);
            assetRepo.save(asset);
        }
        AuctionActivity saved = auctionActivityRepo.save(record);
        if (saved.getStatus().equals(AuctionStatus.NOTSTARTED)) {
            onShelfTask(saved);
        } else if (saved.getStatus().equals(AuctionStatus.ONGOING)) {
            offShelfTask(saved);
        }
        return saved;
    }

    public synchronized String changeStatus(Long id, AuctionStatus status) {
        BoundValueOperations<String, Object> ops = redisTemplate.boundValueOps(RedisKeys.AUCTION_STATUS + id);
        if (ops.get() == null) {
            Boolean success = ops.setIfAbsent(Optional.ofNullable(auctionActivityRepo.getStatus(id))
                    .orElse(AuctionStatus.NOTSTARTED.toString()), 7, TimeUnit.DAYS);
            log.info("创建redis拍卖活动状态：{}", success);
        }
        String stock = (String) ops.getAndSet(status.toString());
        syncStatus(id);
        return stock;
    }

    @Debounce(key = "#id", delay = 500)
    public void syncStatus(Long id) {
        String stock = (String) redisTemplate.opsForValue().get(RedisKeys.AUCTION_STATUS + id);
        if (stock != null) {
            log.info("同步拍卖活动状态信息{}", id);
            auctionActivityRepo.updateStatus(id, AuctionStatus.valueOf(stock));
            cacheService.clearAuction(id);
        }
    }

    private void onShelfTask(AuctionActivity record) {
        ScheduledFuture<?> task = tasks.get(record.getId());
        if (task != null) {
            if (!task.cancel(true)) {
                return;
            }
        }
        if (record.getStatus().equals(AuctionStatus.NOTSTARTED)) {
            if (record.getStartTime().minusSeconds(2).isAfter(LocalDateTime.now())) {
                Date date = Date.from(record.getStartTime().atZone(ZoneId.systemDefault()).toInstant());
                ScheduledFuture<?> future = taskScheduler.schedule(() -> {
                    auctionActivityRepo.scheduleOnShelf(record.getId(), AuctionStatus.ONGOING);
                    tasks.remove(record.getId());
                    offShelfTask(record);
                }, date);
                tasks.put(record.getId(), future);
            } else {
                auctionActivityRepo.scheduleOnShelf(record.getId(), AuctionStatus.ONGOING);
                offShelfTask(record);
            }
        }
    }

    private void offShelfTask(AuctionActivity record) {
        ScheduledFuture<?> task = tasks.get(record.getId());
        if (task != null) {
            if (!task.cancel(true)) {
                return;
            }
        }
        AuctionActivity recordNew1 = auctionActivityRepo.findById(record.getId())
                .orElseThrow(new BusinessException("无数据"));
        if (recordNew1.getStatus().equals(AuctionStatus.ONGOING)) {
            if (recordNew1.getEndTime().minusSeconds(2).isAfter(LocalDateTime.now())) {
                Date date = Date.from(record.getEndTime().atZone(ZoneId.systemDefault()).toInstant());
                ScheduledFuture<?> future = taskScheduler.schedule(() -> {
                    AuctionActivity nowRecord = auctionActivityRepo.findById(record.getId())
                            .orElseThrow(new BusinessException("无数据"));
                    if (nowRecord.getPurchasePrice() != null) {
                        auctionActivityRepo.scheduleOffShelf(nowRecord.getId(), AuctionStatus.PURCHASED);
                    } else {
                        auctionActivityRepo.scheduleOffShelf(nowRecord.getId(), AuctionStatus.PASS);
                        if (record.getAuctionType().equals(AuctionType.NFT)) {
                            Asset asset = assetRepo.findById(nowRecord.getAssetId())
                                    .orElseThrow(new BusinessException("暂无"));
                            asset.setStatus(AssetStatus.NORMAL);
                            asset.setConsignment(false);
                            asset.setPublicShow(false);
                            assetRepo.save(asset);
                        }
                    }
                    tasks.remove(record.getId());
                }, date);
                tasks.put(record.getId(), future);
            } else {
                if (recordNew1.getPurchasePrice() != null) {
                    auctionActivityRepo.scheduleOffShelf(recordNew1.getId(), AuctionStatus.PURCHASED);
                } else {
                    auctionActivityRepo.scheduleOffShelf(recordNew1.getId(), AuctionStatus.PASS);
                    if (record.getAuctionType().equals(AuctionType.NFT)) {
                        Asset asset = assetRepo.findById(recordNew1.getAssetId())
                                .orElseThrow(new BusinessException("暂无"));
                        asset.setStatus(AssetStatus.NORMAL);
                        asset.setConsignment(false);
                        asset.setPublicShow(false);
                        assetRepo.save(asset);
                    }
                }
            }
        }
    }
}