chuangqi_back/src/main/java/com/izouma/nineth/service/scheduledTask/SubscribeTask.java

package com.izouma.nineth.service.scheduledTask;

import cn.hutool.core.util.RandomUtil;
import com.izouma.nineth.domain.Collection;
import com.izouma.nineth.domain.Subscribe;
import com.izouma.nineth.enums.SubscribeStatus;
import com.izouma.nineth.repo.CollectionRepo;
import com.izouma.nineth.repo.SubscribeRepo;
import io.jsonwebtoken.lang.Collections;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Component
@Slf4j
public class SubscribeTask {

    @Autowired
    private CollectionRepo collectionRepo;
    @Autowired
    private SubscribeRepo subscribeRepo;

    private Map<Long, LocalDateTime> collectionMap = new HashMap<>();

//    @Scheduled(cron = "0/5 * * * * ?")
    public void subscriberTask() {
        LocalDateTime startTime = LocalDateTime.now();
        LocalDateTime endTime = startTime.plusSeconds(6);
        List<Collection> ongoingList = collectionRepo
                .findAllByStartTimeGreaterThanAndStartTimeLessThanEqual(startTime, endTime);
        if (!Collections.isEmpty(ongoingList)) {
            for (Collection collection : ongoingList) {
                if (collection.getStartTime().isAfter(startTime) && !collection.getSubscribeStatus().equals(SubscribeStatus.ONGOING)) {
                    collectionRepo.updateSubscribeStatus(collection.getId(), SubscribeStatus.ONGOING);
                }
            }
        }
        List<Collection> subscribeEndingList = collectionRepo
                .findAllByEndTimeGreaterThanAndEndTimeLessThanEqual(startTime, endTime);
        if (!Collections.isEmpty(subscribeEndingList)) {
            for (Collection collection : subscribeEndingList) {
                if (collection.getEndTime().isAfter(startTime) && !collection.getSubscribeStatus().equals(SubscribeStatus.SUBSCRIBE_ENDING)) {
                    collectionRepo.updateSubscribeStatus(collection.getId(), SubscribeStatus.SUBSCRIBE_ENDING);
                }
            }
        }
        List<Collection> collectionList = collectionRepo
                .findAllByEndTimeLessThanEqualAndPublishTimeGreaterThan(startTime, endTime);
        if (!Collections.isEmpty(collectionList)) {
            for (Collection collection : collectionList) {
                if (collectionMap.containsKey(collection.getId())) {
                    if (startTime.isAfter(collectionMap.get(collection.getId()))) {
                        collectionMap.remove(collection.getId());
                    }
                    continue;
                }
                collectionMap.put(collection.getId(), collection.getPublishTime());
                List<Subscribe> subscribeList = subscribeRepo.findAllByCollectionId(collection.getId());
                if (subscribeList.size() <= collection.getStock()) {
                    for (Subscribe subscribe : subscribeList) {
                        subscribeRepo.setPurchaseQualifications(subscribe.getId(), true);
                    }
                } else {
                    ArrayList<Subscribe> subscribes = new ArrayList<>();
                    for (int i = 0; i < collection.getStock(); i++) {
                        subscribes.add(RandomUtil.randomEle(subscribeList));
                    }
                    List<Long> list = subscribes.stream().map(Subscribe::getId).collect(Collectors.toList());
                    for (Long id : list) {
                        subscribeRepo.setPurchaseQualifications(id, true);
                    }
                }
            }
        }
        List<Collection> announcingList = collectionRepo
                .findAllByPublishTimeGreaterThanAndPublishTimeLessThanEqual(startTime, endTime);
        if (!Collections.isEmpty(announcingList)) {
            for (Collection collection : announcingList) {
                if (collection.getPublishTime().isAfter(startTime) && !collection.getSubscribeStatus().equals(SubscribeStatus.ANNOUNCING)) {
                    collectionRepo.updateSubscribeStatus(collection.getId(), SubscribeStatus.ANNOUNCING);
                }
            }
        }
        List<Collection> onSaleList = collectionRepo
                .findAllByPurchaseTimeGreaterThanAndPurchaseTimeLessThanEqual(startTime, endTime);
        if (!Collections.isEmpty(onSaleList)) {
            for (Collection collection : onSaleList) {
                if (collection.getPurchaseTime().isAfter(startTime) && !collection.getSubscribeStatus().equals(SubscribeStatus.ON_SALE)) {
                    collectionRepo.updateSubscribeStatus(collection.getId(), SubscribeStatus.ON_SALE);
                }
            }
        }
    }
}