package com.qianwen.smartman.modules.report.service.impl;

import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.google.common.collect.Lists;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.smartman.common.constant.DateConstant;
import com.qianwen.core.tool.utils.BeanUtil;
import com.qianwen.core.tool.utils.DateUtil;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.smartman.modules.cps.dto.ShiftInfoDTO;
import com.qianwen.smartman.modules.cps.mapper.CalendarMapper;
import com.qianwen.smartman.modules.cps.mapper.WorkstationMapper;
import com.qianwen.smartman.modules.cps.service.IShiftDetailService;
import com.qianwen.smartman.modules.mdc.enums.OpenTypeEnums;
import com.qianwen.smartman.modules.mdc.enums.StatisticalMethodEnum;
import com.qianwen.smartman.modules.mdc.mapper.SuperAlarmMapper;
import com.qianwen.smartman.modules.mdc.utils.FilterOffUtils;
import com.qianwen.smartman.modules.report.dto.WorkstationDataDTO;
import com.qianwen.smartman.modules.report.dto.WorkstationShiftDTO;
import com.qianwen.smartman.modules.report.service.IWorkstationAlarmService;
import com.qianwen.smartman.modules.report.utils.CommonUtil;
import com.qianwen.smartman.modules.report.utils.DateCycleUtil;
import com.qianwen.smartman.modules.report.utils.ResultUtil;
import com.qianwen.smartman.modules.report.vo.DrillWorkstationAlarmByShiftSelectVO;
import com.qianwen.smartman.modules.report.vo.DrillWorkstationAlarmByShiftVO;
import com.qianwen.smartman.modules.report.vo.DrillWorkstationAlarmByTimeSelectVO;
import com.qianwen.smartman.modules.report.vo.DrillWorkstationAlarmByTimeVO;
import com.qianwen.smartman.modules.report.vo.WorkstaionAlarmByShiftReportVO;
import com.qianwen.smartman.modules.report.vo.WorkstaionAlarmByTimeReportVO;
import com.qianwen.smartman.modules.report.vo.WorkstationAlarmByShiftSelectVO;
import com.qianwen.smartman.modules.report.vo.WorkstationAlarmByTimeSelectVO;
import org.springframework.stereotype.Service;

@Service
/* loaded from: blade-api.jar:BOOT-INF/classes/org/springblade/modules/report/service/impl/WorkstationAlarmServiceImpl.class */
public class WorkstationAlarmServiceImpl implements IWorkstationAlarmService {
    private static final Logger log = LoggerFactory.getLogger(WorkstationAlarmServiceImpl.class);
    private final SuperAlarmMapper superAlarmMapper;
    private final WorkstationMapper workstationMapper;
    private final IShiftDetailService shiftDetailService;
    private final CalendarMapper calendarMapper;
    private static final String TIME_CONDITION = "showDate";

    public WorkstationAlarmServiceImpl(final SuperAlarmMapper superAlarmMapper, final WorkstationMapper workstationMapper, final IShiftDetailService shiftDetailService, final CalendarMapper calendarMapper) {
        this.superAlarmMapper = superAlarmMapper;
        this.workstationMapper = workstationMapper;
        this.shiftDetailService = shiftDetailService;
        this.calendarMapper = calendarMapper;
    }

    @Override // org.springblade.modules.report.service.IWorkstationAlarmService
    public JSONObject alarmReportByTime(WorkstationAlarmByTimeSelectVO workstationAlarmByTimeSelectVO) {
        workstationAlarmByTimeSelectVO.setShowDate_begin(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
        workstationAlarmByTimeSelectVO.setShowDate_end(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
        JSONObject jsonObject = new JSONObject();
        IPage<WorkstationDataDTO> workstationVOPage = this.workstationMapper.getWorkstationData(CommonUtil.getIPage(WorkstationDataDTO.class, workstationAlarmByTimeSelectVO.getPageSize(), workstationAlarmByTimeSelectVO.getPageNo(), this.workstationMapper), workstationAlarmByTimeSelectVO.getWorkstationKeyword(), workstationAlarmByTimeSelectVO.getWorkstationIds());
        List<WorkstationDataDTO> voPageRecords = workstationVOPage.getRecords();
        if (Func.isEmpty(voPageRecords)) {
            jsonObject.put("data", (Object) null);
            jsonObject.put("total", Long.valueOf(workstationVOPage.getPages()));
            jsonObject.put("count", Long.valueOf(workstationVOPage.getTotal()));
            return jsonObject;
        }
        CommonUtil.fillWorkStationGroup(workstationVOPage);
        List<Long> workstationIds = (List) voPageRecords.stream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        StatisticalMethodEnum anEnum = StatisticalMethodEnum.of(workstationAlarmByTimeSelectVO.getDateCycle());
        String beginTime = DateCycleUtil.getDateByDateCycle(workstationAlarmByTimeSelectVO.getShowDate_begin(), anEnum, true);
        String endTime = DateCycleUtil.getDateByDateCycle(workstationAlarmByTimeSelectVO.getShowDate_end(), anEnum, false);
        List<String> fillList = DateCycleUtil.fillDateCol(workstationAlarmByTimeSelectVO.getShowDate_begin(), workstationAlarmByTimeSelectVO.getShowDate_end(), anEnum);
        List<WorkstaionAlarmByTimeReportVO> reportData = getData(this.superAlarmMapper.alarmReportByTime(workstationIds, beginTime, endTime));
        List<WorkstaionAlarmByTimeReportVO> result = new ArrayList<>();
        fillList.forEach(dateCol -> {
            voPageRecords.forEach(workstation -> {
                WorkstaionAlarmByTimeReportVO resultVO = new WorkstaionAlarmByTimeReportVO();
                BeanUtil.copyProperties(workstation, resultVO);
                resultVO.setShowDate(dateCol);
                resultVO.setAlarmCount(0);
                resultVO.setAlarmCountSum(0);
                result.add(resultVO);
            });
        });
        Map<String, WorkstaionAlarmByTimeReportVO> voMap = (Map) result.parallelStream().collect(Collectors.toMap(c -> {
            return c.getWorkstationId() + c.getShowDate();
        }, o -> {
            return o;
        }));
        Map<Long, Integer> wsCount = (Map) reportData.parallelStream().collect(Collectors.groupingBy((v0) -> {
            return v0.getWorkstationId();
        }, Collectors.reducing(0, e -> {
            return 1;
        }, (v0, v1) -> {
            return Integer.sum(v0, v1);
        })));
        Map<Long, List<WorkstaionAlarmByTimeReportVO>> workstationOutMap = (Map) reportData.parallelStream().collect(Collectors.groupingBy((v0) -> {
            return v0.getWorkstationId();
        }));
        workstationOutMap.forEach((workstationId, outputList) -> {
            Map<String, Integer> countMap = (Map) outputList.parallelStream().collect(Collectors.groupingBy(groupKey(anEnum), Collectors.reducing(0, e2 -> {
                return 1;
            }, (v0, v1) -> {
                return Integer.sum(v0, v1);
            })));
            countMap.forEach((k, v) -> {
                WorkstaionAlarmByTimeReportVO vo = (WorkstaionAlarmByTimeReportVO) voMap.get(workstationId + k);
                if (!Objects.isNull(vo)) {
                    vo.setAlarmCount(v);
                }
            });
        });
        if (Func.isNotEmpty(result) && Func.isNotEmpty(wsCount)) {
            result.forEach(o2 -> {
                if (wsCount.containsKey(o2.getWorkstationId())) {
                    o2.setAlarmCountSum((Integer) wsCount.get(o2.getWorkstationId()));
                }
            });
        }
        jsonObject.put("data", result);
        jsonObject.put("total", Long.valueOf(workstationVOPage.getPages()));
        jsonObject.put("count", Long.valueOf(workstationVOPage.getTotal()));
        return jsonObject;
    }

    @Override // org.springblade.modules.report.service.IWorkstationAlarmService
    public JSONObject drillAlarmReportByTime(DrillWorkstationAlarmByTimeSelectVO drillWorkstationAlarmByTimeSelectVO) {
        StatisticalMethodEnum anEnum;
        String parseBeginTime;
        String parseEndTime;
        List<DrillWorkstationAlarmByTimeVO> DrillWorkstationAlarmByTimeVO;
        String dateColStr = drillWorkstationAlarmByTimeSelectVO.getCurrentDate();
        if (dateColStr.length() == 10) {
            anEnum = StatisticalMethodEnum.DAY;
            parseBeginTime = dateColStr;
            parseEndTime = dateColStr;
        } else if (dateColStr.contains("周")) {
            anEnum = StatisticalMethodEnum.WEEK;
            int year = Integer.valueOf(dateColStr.substring(0, dateColStr.indexOf("-"))).intValue();
            int weekNo = Integer.valueOf(dateColStr.substring(dateColStr.indexOf("第") + 1, dateColStr.indexOf("周"))).intValue();
            parseBeginTime = DateCycleUtil.getStartDayOfWeekNo(year, weekNo);
            parseEndTime = DateCycleUtil.getEndDayOfWeekNo(year, weekNo);
        } else {
            anEnum = StatisticalMethodEnum.MONTH;
            String[] dateColSplit = dateColStr.split("-");
            parseBeginTime = DateCycleUtil.getFirstDayOfMonth(Integer.valueOf(dateColSplit[0]).intValue(), Integer.valueOf(dateColSplit[1]).intValue());
            parseEndTime = DateCycleUtil.getEndDayOfMonth(Integer.valueOf(dateColSplit[0]).intValue(), Integer.valueOf(dateColSplit[1]).intValue());
        }
        String beginTime = DateCycleUtil.getDateByDateCycle(parseBeginTime, anEnum, true);
        String endTime = DateCycleUtil.getDateByDateCycle(parseEndTime, anEnum, false);
        try {
            boolean filterType = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
            boolean filterShift = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
            Long count = this.superAlarmMapper.drillCountAlarmReport(drillWorkstationAlarmByTimeSelectVO.getWorkstationId(), beginTime, endTime, Boolean.valueOf(filterType), Boolean.valueOf(filterShift));
            if (Func.isEmpty(count)) {
                return ResultUtil.dataToJsonObject(null, 0L, drillWorkstationAlarmByTimeSelectVO.getPageSize());
            }
            Boolean isPrintAll = (Boolean) CommonUtil.getRequestParameter(CommonUtil.PRINT_ALL_KEY, Boolean.class);
            if (!Objects.isNull(isPrintAll) && isPrintAll.booleanValue()) {
                boolean filterType2 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
                boolean filterShift2 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
                DrillWorkstationAlarmByTimeVO = this.superAlarmMapper.drillAlarmReportByTime(null, null, drillWorkstationAlarmByTimeSelectVO.getWorkstationId(), beginTime, endTime, Boolean.valueOf(filterType2), Boolean.valueOf(filterShift2));
            } else {
                boolean filterType3 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
                boolean filterShift3 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
                DrillWorkstationAlarmByTimeVO = this.superAlarmMapper.drillAlarmReportByTime(drillWorkstationAlarmByTimeSelectVO.getPageNo(), drillWorkstationAlarmByTimeSelectVO.getPageSize(), drillWorkstationAlarmByTimeSelectVO.getWorkstationId(), beginTime, endTime, Boolean.valueOf(filterType3), Boolean.valueOf(filterShift3));
            }
            DrillWorkstationAlarmByTimeVO.forEach(o -> {
                o.setShowDate(DateUtil.format(DateUtil.parse(String.valueOf(o.getFactoryDate()), "yyyyMMdd"), DateConstant.PATTERN_DATE));
            });
            return ResultUtil.dataToJsonObject(DrillWorkstationAlarmByTimeVO, count, drillWorkstationAlarmByTimeSelectVO.getPageSize());
        } catch (Exception e) {
            log.error("查询工位报警子表数量异常，异常信息为:", e);
            return ResultUtil.dataToJsonObject(null, 0L, drillWorkstationAlarmByTimeSelectVO.getPageSize());
        }
    }

    @Override // org.springblade.modules.report.service.IWorkstationAlarmService
    public JSONObject alarmReportByShift(WorkstationAlarmByShiftSelectVO workstationAlarmByTimeSelectVO) {
        IPage<WorkstationDataDTO> workstationVOPage;
        workstationAlarmByTimeSelectVO.setShowDate_begin(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.TRUE));
        workstationAlarmByTimeSelectVO.setShowDate_end(DateCycleUtil.setTimeCondition(TIME_CONDITION, Boolean.FALSE));
        JSONObject jsonObject = new JSONObject();
        StatisticalMethodEnum anEnum = StatisticalMethodEnum.DAY;
        List<String> fillDateCol = DateCycleUtil.fillDateCol(workstationAlarmByTimeSelectVO.getShowDate_begin(), workstationAlarmByTimeSelectVO.getShowDate_end(), anEnum);
        IPage<WorkstationDataDTO> workstationVOPage2 = CommonUtil.getIPage(WorkstationDataDTO.class, workstationAlarmByTimeSelectVO.getPageSize(), workstationAlarmByTimeSelectVO.getPageNo(), this.workstationMapper);
        if (Func.isEmpty(workstationAlarmByTimeSelectVO.getShiftIndexName())) {
            workstationVOPage = this.workstationMapper.getWorkstationData(workstationVOPage2, workstationAlarmByTimeSelectVO.getWorkstationKeyword(), workstationAlarmByTimeSelectVO.getWorkstationIds());
        } else {
            workstationVOPage = this.workstationMapper.getWorkstationDataWithIndexName(workstationVOPage2, workstationAlarmByTimeSelectVO.getWorkstationKeyword(), workstationAlarmByTimeSelectVO.getShiftIndexName(), workstationAlarmByTimeSelectVO.getShowDate_begin(), workstationAlarmByTimeSelectVO.getShowDate_end(), workstationAlarmByTimeSelectVO.getWorkstationIds());
        }
        if (Func.isEmpty(workstationVOPage.getRecords())) {
            jsonObject.put("data", (Object) null);
            jsonObject.put("total", Long.valueOf(workstationVOPage.getPages()));
            jsonObject.put("count", Long.valueOf(workstationVOPage.getTotal()));
            return jsonObject;
        }
        CommonUtil.fillWorkStationGroup(workstationVOPage);
        List<WorkstationDataDTO> workstationData = workstationVOPage.getRecords();
        List<Long> ids = (List) workstationData.parallelStream().map((v0) -> {
            return v0.getWorkstationId();
        }).collect(Collectors.toList());
        List<ShiftInfoDTO> shiftInfoDtoList = this.calendarMapper.listShiftInfo(ids, LocalDate.parse(workstationAlarmByTimeSelectVO.getShowDate_begin()), LocalDate.parse(workstationAlarmByTimeSelectVO.getShowDate_end()));
        List<WorkstationShiftDTO> workstationShifts = CommonUtil.dataMerge(workstationData, shiftInfoDtoList);
        List<WorkstationShiftDTO> filter = (List) workstationShifts.parallelStream().filter(CommonUtil.conditionFilter(workstationAlarmByTimeSelectVO.getShiftIndexName(), workstationAlarmByTimeSelectVO.getShiftIndex())).collect(Collectors.toList());
        List<WorkstaionAlarmByShiftReportVO> result = new ArrayList<>();
        fillDateCol.forEach(f -> {
            filter.forEach(shift -> {
                WorkstaionAlarmByShiftReportVO resultVO = new WorkstaionAlarmByShiftReportVO();
                BeanUtil.copyProperties(shift, resultVO);
                resultVO.setShowDate(f);
                resultVO.setAlarmCount(0);
                resultVO.setAlarmCountSum(0);
                result.add(resultVO);
            });
        });
        String beginTime = DateCycleUtil.getDateByDateCycle(workstationAlarmByTimeSelectVO.getShowDate_begin(), anEnum, Boolean.TRUE);
        String endTime = DateCycleUtil.getDateByDateCycle(workstationAlarmByTimeSelectVO.getShowDate_end(), anEnum, Boolean.FALSE);
        boolean filterType = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
        boolean filterShift = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
        List<WorkstaionAlarmByShiftReportVO> voList = this.superAlarmMapper.alarmReportByShift(ids, beginTime, endTime, Boolean.valueOf(filterType), Boolean.valueOf(filterShift));
        Map<String, Integer> wsCount = (Map) voList.parallelStream().collect(Collectors.groupingBy(o -> {
            return o.getWorkstationId() + "-" + o.getShiftIndex();
        }, Collectors.reducing(0, e -> {
            return 1;
        }, (v0, v1) -> {
            return Integer.sum(v0, v1);
        })));
        Map<String, List<WorkstaionAlarmByShiftReportVO>> workstationOutMap = (Map) voList.parallelStream().collect(Collectors.groupingBy(s -> {
            return s.getWorkstationId() + "-" + s.getShiftIndex();
        }));
        Map<String, WorkstaionAlarmByShiftReportVO> voMap = (Map) result.parallelStream().collect(LinkedHashMap::new, (map, c) -> {
            WorkstaionAlarmByShiftReportVO workstaionAlarmByShiftReportVO = (WorkstaionAlarmByShiftReportVO) map.put(c.getWorkstationId() + "-" + c.getShiftIndex() + "-" + c.getShowDate(), c);
        }, (v0, v1) -> {
            v0.putAll(v1);
        });
        workstationOutMap.forEach((key, vos) -> {
            Map<String, Integer> countMap = (Map) vos.parallelStream().collect(Collectors.groupingBy(o2 -> {
                return LocalDate.parse(String.valueOf(o2.getFactoryDate()), DateTimeFormatter.ofPattern("yyyyMMdd")).toString();
            }, Collectors.reducing(0, e2 -> {
                return 1;
            }, (v0, v1) -> {
                return Integer.sum(v0, v1);
            })));
            countMap.forEach((k, v) -> {
                WorkstaionAlarmByShiftReportVO vo = (WorkstaionAlarmByShiftReportVO) voMap.get(key + "-" + k);
                if (!Objects.isNull(vo)) {
                    vo.setAlarmCount(v);
                }
            });
        });
        if (Func.isNotEmpty(result) && Func.isNotEmpty(wsCount)) {
            voMap.values().forEach(o2 -> {
                if (wsCount.containsKey(o2.getWorkstationId() + "-" + o2.getShiftIndex())) {
                    o2.setAlarmCountSum((Integer) wsCount.get(o2.getWorkstationId() + "-" + o2.getShiftIndex()));
                }
            });
        }
        return ResultUtil.dataToJsonObject(voMap.values(), Long.valueOf(workstationVOPage.getTotal()), workstationAlarmByTimeSelectVO.getPageSize());
    }

    @Override // org.springblade.modules.report.service.IWorkstationAlarmService
    public JSONObject drillAlarmReportByShift(DrillWorkstationAlarmByShiftSelectVO drillWorkstationAlarmByShiftSelectVO) {
        List<DrillWorkstationAlarmByShiftVO> drillWorkstationAlarmByTimeVO;
        String beginTime = DateCycleUtil.getDateByDateCycle(drillWorkstationAlarmByShiftSelectVO.getCurrentDate(), StatisticalMethodEnum.DAY, true);
        String shift = StatisticalMethodEnum.SHIFT.getMode();
        try {
            boolean filterType = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
            boolean filterShift = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
            Long count = this.superAlarmMapper.drillCountAlarmReport(drillWorkstationAlarmByShiftSelectVO.getWorkstationId(), beginTime, beginTime, Boolean.valueOf(filterType), Boolean.valueOf(filterShift));
            if (Func.isEmpty(count)) {
                return ResultUtil.dataToJsonObject(null, 0L, drillWorkstationAlarmByShiftSelectVO.getPageSize());
            }
            Boolean isPrintAll = (Boolean) CommonUtil.getRequestParameter(CommonUtil.PRINT_ALL_KEY, Boolean.class);
            if (!Objects.isNull(isPrintAll) && isPrintAll.booleanValue()) {
                boolean filterType2 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
                boolean filterShift2 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
                drillWorkstationAlarmByTimeVO = this.superAlarmMapper.drillAlarmReportByShift(null, null, drillWorkstationAlarmByShiftSelectVO.getWorkstationId(), beginTime, beginTime, Boolean.valueOf(filterType2), Boolean.valueOf(filterShift2));
            } else {
                boolean filterType3 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
                boolean filterShift3 = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
                drillWorkstationAlarmByTimeVO = this.superAlarmMapper.drillAlarmReportByShift(drillWorkstationAlarmByShiftSelectVO.getPageNo(), drillWorkstationAlarmByShiftSelectVO.getPageSize(), drillWorkstationAlarmByShiftSelectVO.getWorkstationId(), beginTime, beginTime, Boolean.valueOf(filterType3), Boolean.valueOf(filterShift3));
            }
            LocalDate currentDate = LocalDate.parse(drillWorkstationAlarmByShiftSelectVO.getCurrentDate(), DateTimeFormatter.ofPattern(DateConstant.PATTERN_DATE));
            List<ShiftInfoDTO> shiftInfoDtoList = this.shiftDetailService.getShiftInfoDtoList(Lists.newArrayList(new Long[]{drillWorkstationAlarmByShiftSelectVO.getWorkstationId()}), currentDate, currentDate);
            Map<Integer, String> shiftMap = (Map) shiftInfoDtoList.stream().collect(Collectors.toMap((v0) -> {
                return v0.getShiftIndex();
            }, (v0) -> {
                return v0.getIndexName();
            }));
            drillWorkstationAlarmByTimeVO.forEach(o -> {
                o.setShiftIndexName(shift + o.getShiftIndex());
                if (shiftMap.containsKey(o.getShiftIndex())) {
                    o.setShiftName((String) shiftMap.get(o.getShiftIndex()));
                } else {
                    o.setShiftName(o.getShiftIndexName());
                }
            });
            return ResultUtil.dataToJsonObject(drillWorkstationAlarmByTimeVO, count, drillWorkstationAlarmByShiftSelectVO.getPageSize());
        } catch (Exception e) {
            log.error("查询工位报警子表数量异常，异常信息为:", e);
            return ResultUtil.dataToJsonObject(null, 0L, drillWorkstationAlarmByShiftSelectVO.getPageSize());
        }
    }

    private Function<WorkstaionAlarmByTimeReportVO, String> groupKey(StatisticalMethodEnum statisticalMethodEnum) {
        switch (statisticalMethodEnum) {
            case DAY:
                return output -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output.getFactoryDate()));
                };
            case WEEK:
                return output2 -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output2.getFactoryWeek()));
                };
            case MONTH:
                return output3 -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output3.getFactoryMonth()));
                };
            default:
                return output4 -> {
                    return DateCycleUtil.getDateCycle(statisticalMethodEnum, String.valueOf(output4.getWorkstationId()));
                };
        }
    }

    private List<WorkstaionAlarmByTimeReportVO> getData(List<WorkstaionAlarmByTimeReportVO> data) {
        boolean filterType = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_TYPE, OpenTypeEnums.ALARM_ANALYSIS);
        boolean filterShift = FilterOffUtils.whetherToFilter(OpenTypeEnums.PARAM_KEY_SHIFT, OpenTypeEnums.ALARM_ANALYSIS);
        if (!filterType && !filterShift) {
            return data;
        }
        return (List) data.stream().filter(item -> {
            return (filterType && item.getShiftTimeType().equals(2)) ? false : true;
        }).filter(item2 -> {
            return !filterShift || item2.getShiftIndex().intValue() > 0;
        }).collect(Collectors.toList());
    }
}