单点登录调整

zouyu

2025-03-19 3647aa5008055528f075ee73002542a1399575ae

 performance-server/src/main/java/com/ruoyi/performance/service/impl/AuxiliaryOutputWorkingHoursServiceImpl.java

@@ -4,13 +4,16 @@
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
import com.alibaba.fastjson2.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.User;
import com.ruoyi.common.utils.QueryWrappers;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.performance.dto.AuxiliaryOutputWorkingHoursDto;
import com.ruoyi.performance.dto.AuxiliaryWorkingHoursDayDto;
import com.ruoyi.performance.mapper.AuxiliaryOutputWorkingHoursMapper;
@@ -20,6 +23,7 @@
import com.ruoyi.performance.service.AuxiliaryOutputWorkingHoursService;
import com.ruoyi.system.mapper.UserMapper;
import org.apache.commons.math3.analysis.function.Power;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
@@ -27,10 +31,7 @@
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -53,118 +54,194 @@
    @Resource
    UserMapper userMapper;


    @Override
    public IPage<AuxiliaryOutputWorkingHoursDto> selectAuxiliaryOutputWorkingHours(Page page, AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto) {
        String dates = auxiliaryOutputWorkingHoursDto.getDateTime();
        auxiliaryOutputWorkingHoursDto.setWeekDay(weekConvert(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay()) ? auxiliaryOutputWorkingHoursDto.getWeekDay() : ""));
        String dateTime1 = auxiliaryOutputWorkingHoursDto.getDateTime1();
        String dateTime2 = auxiliaryOutputWorkingHoursDto.getDateTime2();
        AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHours = new AuxiliaryOutputWorkingHours();
        BeanUtils.copyProperties(auxiliaryOutputWorkingHoursDto, auxiliaryOutputWorkingHours);
        String week = auxiliaryOutputWorkingHoursDto.getWeek();
        auxiliaryOutputWorkingHoursDto.setDateTime(null);
        auxiliaryOutputWorkingHoursDto.setWeek(null);
        List<Long> ids = new ArrayList<>();
        if (ids.size() == 0) {
            ids = null;
        Map<String, Object> map = new HashMap<>();
        List<Integer> ids = new ArrayList<>();
        //判断组长,组员,管理员权限
        User user = userMapper.selectById(Integer.parseInt(SecurityUtils.getLoginUser().getUser().getUserId().toString()));

        List<User> users = userMapper.selectList(new LambdaQueryWrapper<User>().like(User::getName, auxiliaryOutputWorkingHoursDto.getName()));
        if(CollectionUtils.isNotEmpty(users)) {
            ids = users.stream().map(User::getId).distinct().collect(Collectors.toList());
        }
        if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isNotEmpty(week)) {
            String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");


        IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = null;
        if (StringUtils.isNotEmpty(dateTime1) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto)
                            .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59")
             auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHours)
                            .ge("date_time", dateTime1).le("date_time", dateTime2 + " 23:59:59")
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            return auxiliaryOutputWorkingHoursDtoIPage ;
        } else if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isEmpty(week)) {
            String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto)
                            .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59"), ids);
            map.put("body",auxiliaryOutputWorkingHoursDtoIPage );
        } else if (StringUtils.isNotEmpty(dateTime1) && ObjectUtils.isEmpty(week)) {
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHours)
                            .ge("date_time", dateTime1).le("date_time", dateTime2 + " 23:59:59"), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            return auxiliaryOutputWorkingHoursDtoIPage ;
        } else if (ObjectUtils.isEmpty(dates) && ObjectUtils.isNotEmpty(week)) {
            map.put("body",auxiliaryOutputWorkingHoursDtoIPage );
        } else if (StringUtils.isEmpty(dateTime1) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto)
             auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page,
                    QueryWrappers.queryWrappers(auxiliaryOutputWorkingHours)
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            return auxiliaryOutputWorkingHoursDtoIPage ;
            map.put("body", auxiliaryOutputWorkingHoursDtoIPage);
        } else {
            IPage<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto), ids);
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHours(page, QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto), ids);
            for (AuxiliaryOutputWorkingHoursDto record : auxiliaryOutputWorkingHoursDtoIPage.getRecords()) {
                record.setDateTime(record.getDateTime().substring(0,10));
            }
            return auxiliaryOutputWorkingHoursDtoIPage ;
        }
        return auxiliaryOutputWorkingHoursDtoIPage;
    }

    //统计产量工时汇总和辅助工时汇总
    @Override
    public Map<String, Object> collectWorkingHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto) {
        AuxiliaryOutputWorkingHours outputWorkingHours = new AuxiliaryOutputWorkingHours();
        AuxiliaryWorkingHoursDay workingHoursDay = new AuxiliaryWorkingHoursDay();
        List<Long> ids = new ArrayList<>();
        if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay())){
            outputWorkingHours.setWeekDay(auxiliaryOutputWorkingHoursDto.getWeekDay());
            workingHoursDay.setWeekDay(auxiliaryOutputWorkingHoursDto.getWeekDay());
        }
        if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getName())){
            List<User> user = userMapper.selectList(Wrappers.<User>lambdaQuery().like(User::getName, auxiliaryOutputWorkingHoursDto.getName()));
            ids.addAll(user.stream().map(User::getId).collect(Collectors.toList()));
        }
        String dates = auxiliaryOutputWorkingHoursDto.getDateTime();
        auxiliaryOutputWorkingHoursDto.setDateTime(null);
        Map<String, Object> map = new HashMap<>();
        BigDecimal sumOutputWorkTime = BigDecimal.ZERO;
        BigDecimal sumApprovedWorkingHour = BigDecimal.ZERO;

        //判断是组长还是组员还是管理员
        List<AuxiliaryOutputWorkingHours> auxiliaryOutputWorkingHours = new ArrayList<>();
        List<AuxiliaryWorkingHoursDay> auxiliaryWorkingHoursDays = new ArrayList<>();
        if (ids.size() == 0) {
            ids=null;
        }
        if (ObjectUtils.isNotEmpty(dates)) {
            String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            //统计当前用户的产品工时
            auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectLists(QueryWrappers.queryWrappers(outputWorkingHours)
                    .ge("date_time", split[0])
                    .le("date_time", split[1] + " 23:59:59"),ids);
            //统计当前用户的辅助工时
            auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectLists(QueryWrappers.queryWrappers(workingHoursDay)
                    .eq("state","已批准")
                    .ge("date_time", split[0])
                    .le("date_time", split[1] + " 23:59:59"),ids);
        }else if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay())){
            //统计当前用户的产品工时
            auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectLists(QueryWrappers.queryWrappers(outputWorkingHours),ids);
            //统计当前用户的辅助工时
            auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectLists(QueryWrappers.queryWrappers(workingHoursDay).eq("state","已批准"),ids);
        }
        else {
            auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectListByIds(ids);
            auxiliaryWorkingHoursDays = auxiliaryWorkingHoursDayMapper.selectListByIds(ids);
        }
        if (ObjectUtils.isNotEmpty(auxiliaryOutputWorkingHours)) {
            Map<String, BigDecimal> sumMap = new HashMap<>();
            for (AuxiliaryOutputWorkingHours auxiliaryOutputWorkingHour : auxiliaryOutputWorkingHours) {
                if (!sumMap.containsKey(auxiliaryOutputWorkingHour.getManHourGroup()+auxiliaryOutputWorkingHour.getOrderNo()+auxiliaryOutputWorkingHour.getSample())) {
                    sumMap.put(auxiliaryOutputWorkingHour.getManHourGroup()+auxiliaryOutputWorkingHour.getOrderNo()+auxiliaryOutputWorkingHour.getSample(), auxiliaryOutputWorkingHour.getOutputWorkTime());
                }
    @Override
    public Map<String, Object> collectWorkingHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto){
        // 返回的结果
        Map<String, Object> map = new HashMap<>();

        // 判断当前人的权限 是否可查看多人
        List<Integer> ids = getCurrentGroupUserIds(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getName()) ? auxiliaryOutputWorkingHoursDto.getName() : "");

        String dateTime = auxiliaryOutputWorkingHoursDto.getDateTime();
        String startTime = "";
        String endTime = "";
        if(StringUtils.isNotEmpty(dateTime)) {
            List<String> list = JSONArray.parseArray(dateTime, String.class);
            if(list.size() == 1) {
                list = JSONArray.parseArray(list.get(0), String.class);
            }
            sumOutputWorkTime = sumMap.values().stream().reduce(BigDecimal.ZERO, BigDecimal::add);
            startTime = list.get(0)+ " 00:00:00";
            endTime = list.get(1)+ " 23:59:59";
        }
        map.put("产量工时汇总", sumOutputWorkTime);
        if (ObjectUtils.isNotEmpty(auxiliaryWorkingHoursDays)) {
            for (AuxiliaryWorkingHoursDay auxiliaryWorkingHoursDay : auxiliaryWorkingHoursDays) {
                sumApprovedWorkingHour = sumApprovedWorkingHour.add(auxiliaryWorkingHoursDay.getReviewerNonproductiveTime());//复核工时
        String weekConvert = weekConvert(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getWeekDay()) ? auxiliaryOutputWorkingHoursDto.getWeekDay()  : ""  ); // 周次转换
        // 根据条件获取数据
        List<AuxiliaryOutputWorkingHours> auxiliaryOutputWorkingHours = auxiliaryOutputWorkingHoursMapper.selectList(new QueryWrapper<AuxiliaryOutputWorkingHours>()
                .in(CollectionUtils.isNotEmpty(ids), "check_id", ids)
                .like(StringUtils.isNotBlank(auxiliaryOutputWorkingHoursDto.getWeekDay()), "week_day", weekConvert)
                .between(StringUtils.isNotEmpty(dateTime),"date_time", startTime, endTime));

        // 1.产量工时汇总
        // 根据委托编号、样品编号、工时分组 来进行分组统计
        // 加班的工时汇总
        BigDecimal overTime = BigDecimal.ZERO;
        // 过滤出加班的工时
        List<AuxiliaryOutputWorkingHours> overFilter = auxiliaryOutputWorkingHours.stream()
                .filter(item -> Objects.nonNull(item.getOvertimeOrderNo()) && StringUtils.isNotEmpty(item.getOvertimeOrderNo()))
                .collect(Collectors.toList());
        Map<String, List<AuxiliaryOutputWorkingHours>> collect = overFilter.stream()
                .collect(Collectors.groupingBy(item -> item.getOvertimeOrderNo() + "@" + item.getSample() + "@" + item.getManHourGroup()));
        Iterator<Map.Entry<String, List<AuxiliaryOutputWorkingHours>>> iterator = collect.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, List<AuxiliaryOutputWorkingHours>> entry = iterator.next();
            // 同一分组下的只需要算一次
            overTime = add(overTime, BigDecimal.valueOf(entry.getValue().get(0).getOvertimeWorkTime()));
        }
        // 非加班的工时汇总
        BigDecimal workTime = BigDecimal.ZERO;
        List<AuxiliaryOutputWorkingHours> workFilter = auxiliaryOutputWorkingHours.stream()
                .filter(item -> Objects.nonNull(item.getOrderNo()) && StringUtils.isNotEmpty(item.getOrderNo()))
                .collect(Collectors.toList());
        Map<String, List<AuxiliaryOutputWorkingHours>> collect1 = workFilter.stream()
                .collect(Collectors.groupingBy(item -> item.getOrderNo() + "@" + item.getSample() + "@" + item.getManHourGroup()));
        Iterator<Map.Entry<String, List<AuxiliaryOutputWorkingHours>>> iterator1 = collect1.entrySet().iterator();
        while (iterator1.hasNext()) {
            Map.Entry<String, List<AuxiliaryOutputWorkingHours>> entry = iterator1.next();
            workTime = add(workTime, BigDecimal.valueOf(entry.getValue().get(0).getOutputWorkTime()));
        }
        BigDecimal outPutWorkTime = add(overTime, workTime);
        // 2.辅助工时汇总
        BigDecimal dayWorkTime = BigDecimal.ZERO;
        List<AuxiliaryWorkingHoursDay> dayList = auxiliaryWorkingHoursDayMapper.selectList(new QueryWrapper<AuxiliaryWorkingHoursDay>()
                .in(CollectionUtils.isNotEmpty(ids), "name_user", ids)
                .like(StringUtils.isNotBlank(auxiliaryOutputWorkingHoursDto.getWeekDay()), "week_day", auxiliaryOutputWorkingHoursDto.getWeekDay())
                .eq(StringUtils.isNotEmpty(auxiliaryOutputWorkingHoursDto.getState()), "state", auxiliaryOutputWorkingHoursDto.getState())
                .between(StringUtils.isNotEmpty(dateTime),"date_time", startTime, endTime));

        for (AuxiliaryWorkingHoursDay a  : dayList) {
            if(ObjectUtils.isNull(a.getReviewerNonproductiveTime())) {
                dayWorkTime = add(dayWorkTime, BigDecimal.ZERO);
            }else {
                dayWorkTime = add(dayWorkTime, BigDecimal.valueOf(a.getReviewerNonproductiveTime()));
            }
        }
        map.put("辅助工时汇总", sumApprovedWorkingHour);
        return map;
        map.put("产量工时汇总", outPutWorkTime);
        map.put("辅助工时汇总", dayWorkTime);
        return  map;
    }


    public  BigDecimal add(BigDecimal a, BigDecimal b){
        return a.add(b);
    }

    // 周次转换
    public String weekConvert(String week){
        String weekDay = "";
        switch (week) {
            case "1":
                weekDay = "周一";
                break;
            case "2":
                weekDay = "周二";
                break;
            case "3":
                weekDay = "周三";
                break;
            case "4":
                weekDay = "周四";
                break;
            case "5":
                weekDay = "周五";
                break;
            case "6":
                weekDay = "周六";
                break;
            case "0":
                weekDay = "周日";
                break;
        }
        return weekDay;
    }


    /**
     * 获取当前用户组织的用户id
     * @return
     */
    private List<Integer> getCurrentGroupUserIds(){
        return getCurrentGroupUserIds("");
    }

    private List<Integer> getCurrentGroupUserIds(String name){
        List<Integer> ids = new ArrayList<>();
        //判断是组长还是组员还是管理员，根据roleId(7:检验员，8:检验组长)
        Integer userId = Integer.parseInt(SecurityUtils.getLoginUser().getUser().getUserId().toString());
        User user = userMapper.selectById(userId);

        //管理员(不添加限制条件所有人都可以看)
        //不是组长

        return ids;
    }

    //导出
@@ -172,11 +249,25 @@
    public void exportWorkingHours(HttpServletResponse response) throws IOException {
        List<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtos = new ArrayList<>();
        List<AuxiliaryWorkingHoursDayDto> auxiliaryWorkingHoursDayDtos = new ArrayList<>();
        List<Long> ids = new ArrayList<>();
        List<Integer> ids = getCurrentGroupUserIds();
        //查询辅助工时
        auxiliaryWorkingHoursDayDtos = auxiliaryWorkingHoursDayMapper.selectDataByUser(ids);
        //查询统计工时
        auxiliaryOutputWorkingHoursDtos = auxiliaryOutputWorkingHoursMapper.selectDataByUser(ids);
        auxiliaryOutputWorkingHoursDtos = auxiliaryOutputWorkingHoursMapper.selectDataByUser(ids).stream().map(item -> {
            if(Objects.isNull(item.getOvertimeWorkTime())) {
                item.setOvertimeWorkTime((double)0);
            }
            if(Objects.isNull(item.getOvertimeAmount())) {
                item.setOvertimeAmount(0);
            }
            if(Objects.isNull(item.getWorkTime())) {
                item.setWorkTime((double)0);
            }
            if(Objects.isNull(item.getAmount())) {
                item.setAmount(0);
            }
            return item;
        }).collect(Collectors.toList());
        response.setContentType("application/vnd.ms-excel");
        response.setCharacterEncoding("UTF-8");
        // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
@@ -185,73 +276,11 @@
        try {
            // 新建ExcelWriter
            ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();

            WriteSheet mainSheet = EasyExcel.writerSheet(0, "辅助工时导出").head(AuxiliaryWorkingHoursDayDto.class).build();
            excelWriter.write(auxiliaryWorkingHoursDayDtos, mainSheet);

            WriteSheet mainSheet1 = EasyExcel.writerSheet(1, "产量工时导出").head(AuxiliaryOutputWorkingHoursDto.class).build();
            excelWriter.write(auxiliaryOutputWorkingHoursDtos, mainSheet1);
            // 关闭流
            excelWriter.finish();
        } catch (IOException e) {
            throw new RuntimeException("导出失败");
        }
    }

    /**
     * 导出产量工时
     * @param response
     */
    @Override
    public void exportOutputHours(AuxiliaryOutputWorkingHoursDto auxiliaryOutputWorkingHoursDto, HttpServletResponse response) {
        //查询导出的费用统计数据
        String dates = auxiliaryOutputWorkingHoursDto.getDateTime();
        String week = auxiliaryOutputWorkingHoursDto.getWeek();
        auxiliaryOutputWorkingHoursDto.setDateTime(null);
        auxiliaryOutputWorkingHoursDto.setWeek(null);

        List<Long> ids = new ArrayList<>();
        String name = auxiliaryOutputWorkingHoursDto.getName();
        if (ObjectUtils.isNotEmpty(name)) {
            ids.addAll(userMapper.selectList(Wrappers.<User>lambdaQuery().like(User::getName, name)).stream().map(User::getId).collect(Collectors.toList()));
        }

        List<AuxiliaryOutputWorkingHoursDto> auxiliaryOutputWorkingHoursDtoIPage = new ArrayList<>();
        if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isNotEmpty(week)) {
            String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto)
                            .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59")
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);

        } else if (ObjectUtils.isNotEmpty(dates) && ObjectUtils.isEmpty(week)) {
            String[] split = dates.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto)
                            .ge("date_time", split[0]).le("date_time", split[1] + " 23:59:59"), ids);

        } else if (ObjectUtils.isEmpty(dates) && ObjectUtils.isNotEmpty(week)) {
            String[] weeks = week.replaceAll("\\[", "").replaceAll("]", "").replaceAll("\"", "").split(",");
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto)
                            .ge("week", weeks[0]).le("week", weeks[1]), ids);

        } else {
            auxiliaryOutputWorkingHoursDtoIPage = auxiliaryOutputWorkingHoursMapper.selectAuxiliaryOutputWorkingHoursList(QueryWrappers.queryWrappers(auxiliaryOutputWorkingHoursDto), ids);
        }

        try {
            response.setContentType("application/vnd.ms-excel");
            response.setCharacterEncoding("UTF-8");
            // 这里URLEncoder.encode可以防止中文乱码 当然和easyexcel没有关系
            String fileName = URLEncoder.encode("产量工时信息导出", "UTF-8");
            response.setHeader("Content-disposition", "attachment;filename=" + fileName + ".xlsx");
            //新建ExcelWriter
            ExcelWriter excelWriter = EasyExcel.write(response.getOutputStream()).registerWriteHandler(new LongestMatchColumnWidthStyleStrategy()).build();
            //获取sheet0对象
            WriteSheet mainSheet = EasyExcel.writerSheet(0, "产量工时信息导出").head(AuxiliaryOutputWorkingHoursDto.class).build();

            //向sheet0写入数据 传入空list这样只导出表头
            excelWriter.write(auxiliaryOutputWorkingHoursDtoIPage, mainSheet);
            //关闭流
            excelWriter.finish();
        } catch (IOException e) {
            throw new RuntimeException("导出失败");