PainService.java

package com.pipihelper.project.feishu.service;

import cn.hutool.core.collection.CollectionUtil;
import com.pipihelper.project.feishu.dao.PainDao;
import com.pipihelper.project.feishu.entity.Pain;
import lombok.Data;
import lombok.experimental.Accessors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;

@Service
public class PainService {

    @Autowired
    private PainDao painDao;

    private final static List<PindexFloor> pindexFloors = new ArrayList<>();

    static {
        pindexFloors.add(new PindexFloor().setStartIndex(1).setEndIndex(12).setTimeRange("15:00-16:00").setFloor(14));
        pindexFloors.add(new PindexFloor().setStartIndex(13).setEndIndex(24).setTimeRange("16:00-17:00").setFloor(14));
        pindexFloors.add(new PindexFloor().setStartIndex(25).setEndIndex(30).setTimeRange("17:00-17:30").setFloor(14));
    }

    public void create(Pain pain) {
        painDao.create(pain);
    }

    public Pain findById(Integer id) {
        return painDao.findById(id);
    }

    public Pain findByOpenId(String openId) {
        return painDao.findByOpenId(openId);
    }

    public void deleteById(Integer id) {
        painDao.deleteById(id);
    }

    public void update(Pain Pain) {
        painDao.update(Pain);
    }

    public List<Pain> findAll() {
        return painDao.findAll();
    }

    public String getTimeRange(int pindex, int floor) {
        String timeRange = pindexFloors.stream().filter(it -> it.floor != null && it.floor == floor)
                .filter(it -> pindex <= it.getEndIndex() && pindex >= it.getStartIndex()).findFirst().get().timeRange;
        return timeRange;
    }

    public List<Pain> findAllReorderByFloor(int floor) {
        List<Pain> painList = painDao.findAllByFloor(floor);
        if (CollectionUtil.isEmpty(painList)) {
            return new ArrayList<>();
        }
        painList = painList.stream().sorted(Comparator.comparing(Pain::getPindex)).collect(Collectors.toList());
        AtomicInteger atomicInteger = new AtomicInteger(1);
        painList.forEach(pain -> {
            int increment = atomicInteger.getAndIncrement();
            pain.setPindex(increment);
            String timeRange = pindexFloors.stream().filter(it -> it.floor != null && it.floor == floor)
                    .filter(it -> increment <= it.getEndIndex() && increment >= it.getStartIndex()).findFirst().get().timeRange;
            pain.setTimeRange(timeRange);
        });
        return painList;
    }

    public void waitPain(String openId) {
        Pain pain = new Pain();
        pain.setOpenId(openId);
        painDao.waitPain(pain);

    }


    public List<Pain> findListAsc(int limit) {
        return painDao.findListAsc(limit);
    }

    public List<Pain> findBackIndex(Integer pindex, int limit) {
        return painDao.findBackIndex(pindex, limit);
    }

    public void deleteAllByFloor(int floor) {
        painDao.deleteAllByFloor(floor);
    }

    public int updateByOpenId(String robOpenId, String robName, String oldOpenId) {
        return painDao.updateByOpenId(robOpenId, robName, oldOpenId);
    }

    @Data
    @Accessors(chain = true)
    public static class PindexFloor {
        private Integer startIndex;
        private Integer endIndex;
        private String timeRange;
        private Integer floor;
    }
}