guzijian / bsth-alcohol-sign · Files

package com.ruoyi.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageInfo;
import com.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.PageUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.domain.*;
import com.ruoyi.driver.mapper.DriverMapper;
import com.ruoyi.num.domain.RuleNum;
import com.ruoyi.num.service.IRuleNumService;
import com.ruoyi.pojo.dto.DriverDto;
import com.ruoyi.pojo.dto.RuleSchedulingDto;
import com.ruoyi.pojo.dto.SchedulingDto;
import com.ruoyi.pojo.dto.SchedulingSettingDto;
import com.ruoyi.pojo.vo.*;
import com.ruoyi.scheduling.domain.RuleScheduling;
import com.ruoyi.scheduling.service.IRuleSchedulingService;
import com.ruoyi.scheduling.service.impl.RuleSchedulingServiceImpl;
import com.ruoyi.service.*;
import com.ruoyi.utils.ConstDateUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.validation.constraints.NotBlank;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static com.ruoyi.common.RuleSchedulingProperties.*;
import static com.ruoyi.common.WeekEnum.FREE;

/**
 * @author 20412
 */
@Service
public class AttendanceServiceImpl implements AttendanceService {

    /**
     * 中文星期声明
     */
    private static String[] weekDays = {"周日", "周一", "周二", "周三", "周四", "周五", "周六"};

    @Autowired
    private DriverMapper driverMapper;

    @Autowired
    private IRuleSchedulingService ruleSchedulingService;

    @Autowired
    private RuleNumSettingService ruleNumSettingService;

    @Autowired
    private RuleSettingDriverService settingDriverService;

    @Autowired
    private RuleSettingSchedulingService settingSchedulingService;

    @Autowired
    private RuleAttendanceMainService attendanceMainService;

    @Autowired
    private RuleAttendanceMainHelpService helpService;

    @Autowired
    private IRuleNumService ruleNumService;


    @Override
    public List<PeopleResponseVo> getDriverInfo(Long id) {
        List<PeopleResponseVo> vos;
        if (id != null) {
            vos = driverMapper.queryAttendanceInfoById(id);
        } else {
            // 获取所有为设置考勤的人员
            vos = driverMapper.queryAttendanceInfoAll();
        }
        return vos;
    }

    @Override
    public List<SchedulingResponseVo> getSchedulingList(SchedulingRequestVo vo) {
        // 查询排班设置表
        PageUtils.startPage();
        List<SchedulingResponseVo> vos = ruleNumSettingService.getSchedulingList(vo);
        if (CollectionUtil.isEmpty(vos)) {
            return vos;
        }
        List<Integer> settingIdList = vos.stream().map(SchedulingResponseVo::getId).collect(Collectors.toList());
        // 查询对应的规则
        List<DriverDto> driverList = settingDriverService.queryDriverListBySettingId(settingIdList);
        List<RuleSchedulingDto> schedulingList = settingSchedulingService.querySchedulingListBySettingId(settingIdList);
        handleSchedulingResponse(vos, driverList, schedulingList);
        return vos;
    }

    @Override
    public List<RuleNumTemplateVo> getTemplate(Long id) {
        RuleNum ruleNum = ruleNumService.selectRuleNumById(id);
        if (Objects.isNull(ruleNum)) {
            return null;
        }
        // 当为固定规则时
        if (RULE_TYPE_FIXED.equals(ruleNum.getRuleType())) {
            return handleFixedTemplate(ruleNum);
        }
        // 处理按星期
        else {
            return handleWeekTemplate(ruleNum);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void saveSchedulingSetting(SchedulingSettingDto dto) {
        RuleNumSetting setting = getRuleNumSetting(dto);
        ruleNumSettingService.save(setting);
        List<RuleSettingScheduling> schedulingList = getSettingSchedulingList(dto, setting.getId());
        settingSchedulingService.saveBatch(schedulingList);
        if (CollectionUtil.isNotEmpty(dto.getPeopleList())) {
            List<RuleSettingDriver> peopleList = getSettingDriverList(dto, setting.getId());
            settingDriverService.remove(new QueryWrapper<RuleSettingDriver>().lambda().in(RuleSettingDriver::getJobCode, peopleList.stream().map(RuleSettingDriver::getJobCode).collect(Collectors.toList())));
            settingDriverService.saveBatch(peopleList);
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateSchedulingSetting(SchedulingDto dto) {
        RuleNumSetting setting = new RuleNumSetting();
        getRumSettingByDto(dto, setting);
        ruleNumSettingService.updateById(setting);
        // 更新规则
        settingSchedulingService.remove(new QueryWrapper<RuleSettingScheduling>().lambda().eq(RuleSettingScheduling::getSettingId, dto.getId()));
        settingSchedulingService.saveBatch(dto.getRuleSchedulingList());
        // 更新人员
        settingDriverService.remove(new QueryWrapper<RuleSettingDriver>()
                .lambda()
                .eq(RuleSettingDriver::getSettingId, dto.getId()));
        settingDriverService.saveBatch(dto.getPeopleList());
    }

    @Override
    public void deleteSchedulingSetting(Integer settingId) {
        ruleNumSettingService.removeById(settingId);
        // 更新规则
        settingSchedulingService.remove(new QueryWrapper<RuleSettingScheduling>().lambda().eq(RuleSettingScheduling::getSettingId, settingId));
        // 更新人员
        settingDriverService.remove(new QueryWrapper<RuleSettingDriver>()
                .lambda()
                .eq(RuleSettingDriver::getSettingId, settingId));
    }

    @Override
    public List<RuleAttendanceMain> queryAttendanceMain(RuleAttendanceMainRequestVo vo) {
        PageUtils.startPage();
        List<RuleAttendanceMain> list = attendanceMainService.list(new QueryWrapper<RuleAttendanceMain>()
                .lambda()
                .eq(RuleAttendanceMain::getSchedulingDate, vo.getDate())
                .eq(StringUtils.isNotEmpty(vo.getJobCode()), RuleAttendanceMain::getJobCode, vo.getJobCode()));
        return list;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateAttendance(UpdateAttendanceVo vo) {
        RuleAttendanceMain main = new RuleAttendanceMain();
        RuleScheduling ruleScheduling = ruleSchedulingService.selectRuleSchedulingById(vo.getRuleId().longValue());
        BeanUtils.copyProperties(ruleScheduling, main);
        List<RuleAttendanceMain> mainList = handleRuleUpdate(vo, main, ruleScheduling);
        attendanceMainService.updateByJobCodeTotalQuantity(vo, mainList);
    }

    private static  List<RuleAttendanceMain> handleRuleUpdate(UpdateAttendanceVo vo, RuleAttendanceMain main, RuleScheduling ruleScheduling) {
        List<RuleAttendanceMain> mainList = new ArrayList<>();
        LocalDate startDate = LocalDate.parse(vo.getStartDate());
        LocalDate endDate = LocalDate.parse(vo.getEndDate());
        while (startDate.compareTo(endDate) <= 0) {
            handleSegmentation(main, ruleScheduling, mainList, startDate);
            startDate = startDate.plusDays(1);
        }
        return mainList;
    }

    private static void handleSegmentation(RuleAttendanceMain main, RuleScheduling ruleScheduling, List<RuleAttendanceMain> mainList, LocalDate startDate) {
        RuleAttendanceMain nowMain = new RuleAttendanceMain();
        BeanUtils.copyProperties(main,nowMain);
        nowMain.setFirstWorkSignInTime(ConstDateUtil.dateAddition(startDate.toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getFirstWorkSignInTime())));
        if (HAVE_SEGMENTATION.equals(ruleScheduling.getSecondFlag())) {
            nowMain.setFirstQuittingSignInTime(ConstDateUtil.dateAddition(startDate.toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getFirstQuittingSignInTime())));
            nowMain.setSecondWorkSignInTime(ConstDateUtil.dateAddition(startDate.toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getSecondWorkSignInTime())));
            // 处理隔天
            if (TOMORROW_YES.equals(ruleScheduling.getFirstSignInDayTomorrow())) {
                nowMain.setSecondQuittingSignInTime(ConstDateUtil.dateAddition(startDate.plusDays(1).toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getSecondQuittingSignInTime())));
            } else {
                nowMain.setSecondQuittingSignInTime(ConstDateUtil.dateAddition(startDate.toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getSecondQuittingSignInTime())));
            }
        } else {
            // 处理隔天
            if (TOMORROW_YES.equals(ruleScheduling.getFirstSignInDayTomorrow())) {
                nowMain.setFirstQuittingSignInTime(ConstDateUtil.dateAddition(startDate.plusDays(1).toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getFirstQuittingSignInTime())));
            } else {
                nowMain.setFirstQuittingSignInTime(ConstDateUtil.dateAddition(startDate.toString(), ConstDateUtil.formatDate("HH:mm:ss", nowMain.getFirstQuittingSignInTime())));
            }
        }
        nowMain.setWorkFlag(ruleScheduling.getId() == 0 ? FREE_FLAG : WORK_FLAG);
        nowMain.setSchedulingDate(Date.from(startDate.atStartOfDay(ZoneId.systemDefault()).toInstant()));
        mainList.add(nowMain);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteAttendance(DeleteAttendanceVo vo) {
        attendanceMainService.deleteByJobCodeTotalRecord(vo);
    }

    @Override
    public TableDataInfo getTableMonth(PeopleRequestVo vo) {
        PageUtils.startPage();
        List<RuleAttendanceMainHelp> helpList = attendanceMainService.queryPeopleList(vo);
        long total = new PageInfo(helpList).getTotal();
        List<String> jobCodes = helpList.stream().map(RuleAttendanceMainHelp::getJobCode).collect(Collectors.toList());
        List<RuleAttendanceMain> mainList = attendanceMainService.queryNowMonthDate(vo, jobCodes);
        List<TableMonthResponseVo> voList = handleTableMonthResponseVo(vo.getDate(), helpList, mainList);
        return getDataTable(voList, total);
    }

    /**
     * 响应请求分页数据
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    protected TableDataInfo getDataTable(List<?> list, Long total) {
        TableDataInfo rspData = new TableDataInfo();
        rspData.setCode(HttpStatus.SUCCESS);
        rspData.setMsg("查询成功");
        rspData.setRows(list);
        rspData.setTotal(total);
        return rspData;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateSchedulingByUser(UpdatePeopleAttendanceRequestVo vo) {
        if (NOW_RULE.equals(vo.getType())) {
            ruleCopyToOtherUser(vo);
        } else if (OTHER_RULE.equals(vo.getType())) {
            handleOtherRule(vo);
        }
    }

    @Override
    public List<PeopleResponseVo> getTodayFreeUser(String date) {
        LocalDate localDate = LocalDate.parse(date);
        QueryWrapper<RuleAttendanceMain> qw = new QueryWrapper<>();
        qw.lambda()
                .eq(RuleAttendanceMain::getSchedulingDate, localDate)
                .eq(RuleAttendanceMain::getWorkFlag, FREE_FLAG);
        List<RuleAttendanceMain> mainList = attendanceMainService.list(qw);
        List<PeopleResponseVo> peopleList = mainTransformPeopleResponseVo(mainList);
        return peopleList;
    }

    private List<PeopleResponseVo> mainTransformPeopleResponseVo(List<RuleAttendanceMain> mainList) {
        List<PeopleResponseVo> vos = new ArrayList<>(mainList.size());
        for (RuleAttendanceMain main : mainList) {
            PeopleResponseVo vo = new PeopleResponseVo();
            BeanUtils.copyProperties(main, vo);
            vos.add(vo);
        }
        return vos;
    }

    private void handleOtherRule(UpdatePeopleAttendanceRequestVo vo) {
        RuleAttendanceMain main = getRuleAttendanceMain(vo.getJobCode(), vo);
        RuleAttendanceMain otherMain = getRuleAttendanceMain(vo.getOtherJobCode(), vo);
        RuleScheduling ruleScheduling = ruleSchedulingService.selectRuleSchedulingById(vo.getRuleId().longValue());
        // 更新休息
        BeanUtils.copyProperties(otherMain, main, "id", "name", "posts", "fleetName", "ruleDictName", "jobCode");
        attendanceMainService.updateById(main);

        // 更新顶班人员规则
        handleOtherMain(ruleScheduling, otherMain, vo.getDate());
        attendanceMainService.updateById(otherMain);
    }

    private void handleOtherMain(RuleScheduling ruleScheduling, RuleAttendanceMain otherMain, String date) {
        RuleSchedulingDto dto = new RuleSchedulingDto();
        BeanUtils.copyProperties(ruleScheduling, dto);

        BeanUtils.copyProperties(dto, otherMain);
        RuleNumSettingServiceImpl.handleSegmentationByDate(LocalDate.parse(date), otherMain, dto);
        otherMain.setWorkFlag(dto.getId() == 0 ? FREE_FLAG : WORK_FLAG);
    }

    private void ruleCopyToOtherUser(UpdatePeopleAttendanceRequestVo vo) {
        RuleAttendanceMain main = getRuleAttendanceMain(vo.getJobCode(), vo);

        RuleAttendanceMain otherMain = getRuleAttendanceMain(vo.getOtherJobCode(), vo);
        RuleAttendanceMain backMain = new RuleAttendanceMain();
        BeanUtils.copyProperties(otherMain, backMain);

        BeanUtils.copyProperties(main, otherMain, "id", "name", "posts", "fleetName", "ruleDictName", "jobCode");
        attendanceMainService.updateById(otherMain);
        // 更新休息
        BeanUtils.copyProperties(backMain, main, "id", "name", "posts", "fleetName", "ruleDictName", "jobCode");
        attendanceMainService.updateById(main);
    }

    private RuleAttendanceMain getRuleAttendanceMain(String vo, UpdatePeopleAttendanceRequestVo vo1) {
        QueryWrapper<RuleAttendanceMain> qw = new QueryWrapper<>();
        qw.lambda().eq(RuleAttendanceMain::getJobCode, vo)
                .eq(RuleAttendanceMain::getSchedulingDate, vo1.getDate());
        RuleAttendanceMain main = attendanceMainService.getOne(qw);
        return main;
    }

    private List<TableMonthResponseVo> handleTableMonthResponseVo(@NotBlank String date, List<RuleAttendanceMainHelp> helpList, List<RuleAttendanceMain> mainList) {
        Map<String, List<RuleAttendanceMain>> mainMap = transformMapByRuleAttendanceMain(mainList);
        List<TableMonthResponseVo> vos = new ArrayList<>(10);
        for (RuleAttendanceMainHelp help : helpList) {
            TableMonthResponseVo vo = new TableMonthResponseVo();
            BeanUtils.copyProperties(help, vo);
            vo.setMonthList(handleMonthWorkList(date, mainMap.get(help.getJobCode())));
            vos.add(vo);
        }
        return vos;
    }

    private List<TableMonthResponseVo.WorkItemVo> handleMonthWorkList(@NotBlank String date, List<RuleAttendanceMain> mains) {
        List<TableMonthResponseVo.WorkItemVo> vos = new ArrayList<>(30);
        for (RuleAttendanceMain main : mains) {
            TableMonthResponseVo.WorkItemVo itemVo = new TableMonthResponseVo.WorkItemVo();
            itemVo.setSchedulingDate(main.getSchedulingDate());
            itemVo.setRangeTime(handleRangeTime(main));
            itemVo.setDay(ConstDateUtil.formatDate("MM月dd日", main.getSchedulingDate()));
            itemVo.setWeek(handleNowWeek(main.getSchedulingDate()));
            vos.add(itemVo);
        }
        // 为未生成的日期进行补充
        String[] split = date.split(TOMORROW_NO_STRING);
        int year = Integer.parseInt(split[0]);
        int month = Integer.parseInt(split[1]);
        List<LocalDate> dateList = ConstDateUtil.getAllDatesOfTheMonth(year, month);
        if (vos.size() != dateList.size()) {
            int diff = DateUtils.differentDaysByMillisecond(Date.from(dateList.get(0).atStartOfDay(ZoneId.systemDefault()).toInstant()), vos.get(0).getSchedulingDate());
            if (diff > 0) {
                for (int i = 0; i < diff; i++) {
                    TableMonthResponseVo.WorkItemVo itemVo = new TableMonthResponseVo.WorkItemVo();
                    LocalDate localDate = dateList.get(i);
                    Date nowDate = Date.from(localDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
                    itemVo.setSchedulingDate(nowDate);
                    itemVo.setDay(ConstDateUtil.formatDate("MM月dd日", nowDate));
                    itemVo.setWeek(handleNowWeek(nowDate));
                    vos.add(itemVo);
                }
                vos.sort(Comparator.comparing(TableMonthResponseVo.WorkItemVo::getSchedulingDate));
            }
        }
        return vos;
    }

    private String handleNowWeek(Date date) {
        Calendar cal = Calendar.getInstance(); // 获得一个日历
        cal.setTime(date);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1; // 指示一个星期中的某天。
        if (w < 0) {
            w = 0;
        }
        return weekDays[w];
    }

    private String handleRangeTime(RuleAttendanceMain main) {
        // 处理休息
        if (FREE.getValue().equals(main.getWorkFlag())) {
            return FREE.getDescription();
        }
        String rangeTime;
        // 处理不分段
        if (Objects.isNull(main.getSecondQuittingSignInTime())) {
            rangeTime = handleFirstRangeTime(main);
        } else {
            rangeTime = handleFirstRangeTime(main) + ";" + handleSecondRangeTime(main);
        }
        return rangeTime;
    }

    private String handleSecondRangeTime(RuleAttendanceMain main) {
        return ConstDateUtil.formatDate("MM月dd日HH:mm", main.getSecondWorkSignInTime()) + TOMORROW_NO_STRING + ConstDateUtil.formatDate("MM月dd日HH:mm", main.getSecondQuittingSignInTime());
    }

    private String handleFirstRangeTime(RuleAttendanceMain main) {
        return ConstDateUtil.formatDate("MM月dd日HH:mm", main.getFirstWorkSignInTime()) + TOMORROW_NO_STRING + ConstDateUtil.formatDate("MM月dd日HH:mm", main.getFirstQuittingSignInTime());
    }

    private Map<String, List<RuleAttendanceMain>> transformMapByRuleAttendanceMain(List<RuleAttendanceMain> mainList) {
        Map<String, List<RuleAttendanceMain>> map = new HashMap<>();
        for (RuleAttendanceMain main : mainList) {
            List<RuleAttendanceMain> mains = map.get(main.getJobCode());
            if (CollectionUtil.isEmpty(mains)) {
                map.put(main.getJobCode(), new ArrayList<>(Arrays.asList(main)));
            } else {
                mains.add(main);
            }
        }
        return map;
    }

    private static void getRumSettingByDto(SchedulingDto dto, RuleNumSetting setting) {
        setting.setId(dto.getId());
        setting.setUpdateTime(DateUtils.getNowDate());
        setting.setUpdateBy(SecurityUtils.getUsername());
        setting.setRuleNumId(dto.getRuleNumId());
        setting.setRuleDictName(dto.getRuleDictName());
    }

    private List<RuleSettingDriver> getSettingDriverList(SchedulingSettingDto dto, Integer id) {
        return dto
                .getPeopleList()
                .stream()
                .map(item -> {
                    RuleSettingDriver driver = new RuleSettingDriver();
                    driver.setSettingId(id);
                    driver.setJobCode(item.getJobCode());
                    if (item.getStartDate() == null) {
                        throw new RuntimeException("非法开始时间");
                    }
                    driver.setStartDate(item.getStartDate());
                    return driver;
                })
                .collect(Collectors.toList());
    }

    private List<RuleSettingScheduling> getSettingSchedulingList(SchedulingSettingDto dto, Integer id) {
        // TODO 规则校验
        return dto.getRuleSchedulingList().stream().peek(item -> {
            item.setSettingId(id);
        }).collect(Collectors.toList());
    }

    private static RuleNumSetting getRuleNumSetting(SchedulingSettingDto dto) {
        RuleNumSetting setting = new RuleNumSetting();
        setting.setCreateTime(DateUtils.getNowDate());
        setting.setUpdateTime(DateUtils.getNowDate());
        String username = SecurityUtils.getUsername();
        setting.setCreateBy(username);
        setting.setUpdateBy(username);
        setting.setRuleDictName(dto.getRuleDictName());
        setting.setRuleNumId(dto.getRuleNumId());
        return setting;
    }

    private List<RuleNumTemplateVo> handleWeekTemplate(RuleNum ruleNum) {
        String[] strings = ruleNum.getRuleWeek().split(",");
        Map<Integer, Integer> weeks = Stream.of(strings).collect(Collectors.toMap(s -> Integer.parseInt(s), s -> Integer.parseInt(s)));
        List<RuleNumTemplateVo> vos = new ArrayList<>(7);
        for (int i = 1; i <= 7; i++) {
            Integer integer = weeks.get(i);
            if (Objects.isNull(integer)) {
                vos.add(getRuleNumTemplateVo(i, false));
            } else {
                vos.add(getRuleNumTemplateVo(integer, true));
            }
        }
        return vos;
    }

    private List<RuleNumTemplateVo> handleFixedTemplate(RuleNum ruleNum) {
        int countDay = ruleNum.getWorkDay() + ruleNum.getFreeDay();
        List<RuleNumTemplateVo> vos = new ArrayList<>(countDay);
        for (int i = 1; i <= countDay; i++) {
            vos.add(getRuleNumTemplateVo(i, i <= ruleNum.getWorkDay()));
        }
        return vos;
    }

    private RuleNumTemplateVo getRuleNumTemplateVo(Integer serialNumber, Boolean workFlag) {
        RuleNumTemplateVo vo = new RuleNumTemplateVo();
        vo.setSerialNumber(serialNumber);
        vo.setType(workFlag ? WORK_FLAG : FREE_FLAG);
        return vo;
    }

    private void handleSchedulingResponse(List<SchedulingResponseVo> vos, List<DriverDto> driverList, List<RuleSchedulingDto> schedulingList) {
        Map<Integer, List<DriverDto>> driverMap = transFromMapByDriver(driverList);
        Map<Integer, List<RuleScheduling>> schedulingMap = transFromMapByScheduling(schedulingList);
        for (SchedulingResponseVo vo : vos) {
            vo.setPeopleList(handlePeopleList(vo.getId(), driverMap.get(vo.getId())));
            vo.setRuleList(handleRuleList(vo.getId(), schedulingMap.get(vo.getId())));
        }
    }

    private Map<Integer, List<RuleScheduling>> transFromMapByScheduling(List<RuleSchedulingDto> schedulingList) {
        Map<Integer, List<RuleScheduling>> map = new HashMap<>(16);
        for (RuleSchedulingDto scheduling : schedulingList) {
            List<RuleScheduling> list = map.get(scheduling.getSettingId());
            if (CollectionUtil.isEmpty(list)) {
                map.put(scheduling.getSettingId(), new ArrayList<>(Arrays.asList(scheduling)));
            } else {
                list.add(scheduling);
            }
        }
        return map;
    }

    private Map<Integer, List<DriverDto>> transFromMapByDriver(List<DriverDto> driverList) {
        Map<Integer, List<DriverDto>> map = new HashMap<>(16);
        for (DriverDto driver : driverList) {
            List<DriverDto> list = map.get(driver.getSettingId());
            if (CollectionUtil.isEmpty(list)) {
                map.put(driver.getSettingId(), new ArrayList<>(Arrays.asList(driver)));
            } else {
                list.add(driver);
            }
        }
        return map;
    }

    private List<String> handleRuleList(Integer id, List<RuleScheduling> schedulingList) {
        List<RuleSchedulingVo> list = RuleSchedulingServiceImpl.handleRuleScheduling(schedulingList);
        if (CollectionUtil.isEmpty(list)) {
            return new ArrayList<>();
        }
        return list.stream().map(item -> {
            if (item.getRuleName().equals(FREE.getDescription())) {
                return item.getRuleName();
            }
            return item.getRuleName() + "(" + item.getRangeTime() + ")";
        }).collect(Collectors.toList());
    }

    private List<String> handlePeopleList(Integer id, List<DriverDto> driverList) {
        if (CollectionUtil.isEmpty(driverList)) {
            return new ArrayList<>();
        }
        return driverList.stream().map(item -> item.getPersonnelName() + "(" + item.getJobCode() + ")").collect(Collectors.toList());
    }
}