usky-power/fiveep-service/src/main/java/com/bizmatics/service/impl/DevopsWorkOrderServiceImpl.java

package com.bizmatics.service.impl;

import cn.afterturn.easypoi.excel.ExcelExportUtil;
import cn.afterturn.easypoi.excel.entity.ExportParams;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.bizmatics.common.core.bean.CommonPage;
import com.bizmatics.common.core.exception.BusinessException;
import com.bizmatics.common.core.util.BeanMapperUtils;
import com.bizmatics.common.core.util.FileUtils;
import com.bizmatics.common.mvc.base.AbstractCrudService;
import com.bizmatics.common.spring.util.GlobalUtils;
import com.bizmatics.model.*;
import com.bizmatics.model.system.SysUser;
import com.bizmatics.model.vo.*;
import com.bizmatics.persistence.mapper.DevopsWorkOrderMapper;
import com.bizmatics.service.*;
import com.bizmatics.service.util.SecurityUtils;
import com.bizmatics.service.vo.DeviceExportVO;
import com.bizmatics.service.vo.ProcessingTimeExportVO;
import org.apache.poi.ss.usermodel.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 运维管理-工单管理
 *
 * @author ya
 * @since 2021-10-21
 */
@Service
public class DevopsWorkOrderServiceImpl extends AbstractCrudService<DevopsWorkOrderMapper, DevopsWorkOrder> implements DevopsWorkOrderService {

    @Autowired
    private DevopsOrderDeviceService devopsOrderDeviceService;

    @Autowired
    private DevopsOrderInspectorsService devopsOrderInspectorsService;
    @Autowired
    private PatrolInspectionRecordService patrolInspectionRecordService;

    @Autowired
    private PatrolRecordRouteService patrolRecordRouteService;

    @Autowired
    private PatrolInspectorsService patrolInspectorsService;

    @Autowired
    private PatrolInspectionTeamService patrolInspectionTeamService;

    @Override
    public void devopsWorkOrderAdd(DevopsWorkOrderVo devopsWorkOrderVo) {
        DevopsWorkOrder devopsWorkOrder = new DevopsWorkOrder();
        SysUser user = SecurityUtils.getLoginUser().getUser();
        devopsWorkOrder.setWorkOrder(devopsWorkOrderVo.getWorkOrder());
        devopsWorkOrder.setSiteId(devopsWorkOrderVo.getSiteId());
        devopsWorkOrder.setWorkOrderType(devopsWorkOrderVo.getWorkOrderType());
        devopsWorkOrder.setExpectedCompletionTime(devopsWorkOrderVo.getExpectedCompletionTime());
        devopsWorkOrder.setTeamId(devopsWorkOrderVo.getTeamId());
        devopsWorkOrder.setGenerationMode(devopsWorkOrderVo.getGenerationMode());
        devopsWorkOrder.setWorkOrderStatus(3);
        devopsWorkOrder.setPicturePathOne(devopsWorkOrderVo.getPicturePathOne());
        devopsWorkOrder.setPicturePathTwo(devopsWorkOrderVo.getPicturePathTwo());
        devopsWorkOrder.setPicturePathThree(devopsWorkOrderVo.getPicturePathThree());
        devopsWorkOrder.setPicturePathFour(devopsWorkOrderVo.getPicturePathFour());
        devopsWorkOrder.setPicturePathFive(devopsWorkOrderVo.getPicturePathFive());
        devopsWorkOrder.setPicturePathSix(devopsWorkOrderVo.getPicturePathSix());
        devopsWorkOrder.setCreator(user.getUserName());
        devopsWorkOrder.setCreateTime(new Date());
        devopsWorkOrder.setStatus(1);
        this.save(devopsWorkOrder);
        Integer devopsWorkOrderId = devopsWorkOrder.getId();
        String[] inspectionDeviceIdList = devopsWorkOrderVo.getInspectionDeviceId().split(",");
        String[] inspectorsIdList = devopsWorkOrderVo.getInspectorsId().split(",");
        for (int i = 0; i < inspectionDeviceIdList.length; i++) {
            DevopsOrderDevice devopsOrderDevice = new DevopsOrderDevice();
            devopsOrderDevice.setWorkOrderId(devopsWorkOrderId);
            devopsOrderDevice.setInspectionDeviceId(Integer.parseInt(inspectionDeviceIdList[i]));
            devopsOrderDevice.setCreator(user.getUserName());
            devopsOrderDevice.setCreateTime(new Date());
            devopsOrderDevice.setStatus(1);
            devopsOrderDeviceService.save(devopsOrderDevice);
        }

        for (int i = 0; i < inspectorsIdList.length; i++) {
            DevopsOrderInspectors devopsOrderInspectors = new DevopsOrderInspectors();
            devopsOrderInspectors.setWorkOrderId(devopsWorkOrderId);
            devopsOrderInspectors.setInspectorsId(Integer.parseInt(inspectorsIdList[i]));
            devopsOrderInspectors.setCreator(user.getUserName());
            devopsOrderInspectors.setCreateTime(new Date());
            devopsOrderInspectors.setStatus(1);
            devopsOrderInspectorsService.save(devopsOrderInspectors);
        }
    }

    @Override
    public void devopsWorkOrderUpdate(DevopsWorkOrderVo devopsWorkOrderVo) {
        SysUser user = SecurityUtils.getLoginUser().getUser();
        DevopsWorkOrder devopsWorkOrder = new DevopsWorkOrder();
        devopsWorkOrder.setId(devopsWorkOrderVo.getId());
        devopsWorkOrder.setWorkOrder(devopsWorkOrderVo.getWorkOrder());
        devopsWorkOrder.setWorkOrderType(devopsWorkOrderVo.getWorkOrderType());
        devopsWorkOrder.setExpectedCompletionTime(devopsWorkOrderVo.getExpectedCompletionTime());
        devopsWorkOrder.setTeamId(devopsWorkOrderVo.getTeamId());
        devopsWorkOrder.setGenerationMode(devopsWorkOrderVo.getGenerationMode());
        devopsWorkOrder.setWorkOrderStatus(devopsWorkOrderVo.getWorkOrderStatus());
        devopsWorkOrder.setPicturePathOne(devopsWorkOrderVo.getPicturePathOne());
        devopsWorkOrder.setPicturePathTwo(devopsWorkOrderVo.getPicturePathTwo());
        devopsWorkOrder.setPicturePathThree(devopsWorkOrderVo.getPicturePathThree());
        devopsWorkOrder.setPicturePathFour(devopsWorkOrderVo.getPicturePathFour());
        devopsWorkOrder.setPicturePathFive(devopsWorkOrderVo.getPicturePathFive());
        devopsWorkOrder.setPicturePathSix(devopsWorkOrderVo.getPicturePathSix());
        this.updateById(devopsWorkOrder);
        Integer devopsWorkOrderId = devopsWorkOrder.getId();
        String[] inspectionDeviceIdList = devopsWorkOrderVo.getInspectionDeviceId().split(",");
        String[] inspectorsIdList = devopsWorkOrderVo.getInspectorsId().split(",");
        if (inspectionDeviceIdList.length > 0) {
            for (int i = 0; i < inspectionDeviceIdList.length; i++) {
                DevopsOrderDevice devopsOrderDevice = new DevopsOrderDevice();
                devopsOrderDevice.setWorkOrderId(devopsWorkOrderId);
                devopsOrderDevice.setInspectionDeviceId(Integer.parseInt(inspectionDeviceIdList[i]));
                devopsOrderDevice.setCreator(user.getUserName());
                devopsOrderDevice.setCreateTime(new Date());
                devopsOrderDevice.setStatus(1);
                devopsOrderDeviceService.save(devopsOrderDevice);
            }
        }
        if (inspectorsIdList.length > 0) {
            for (int i = 0; i < inspectorsIdList.length; i++) {
                DevopsOrderInspectors devopsOrderInspectors = new DevopsOrderInspectors();
                devopsOrderInspectors.setWorkOrderId(devopsWorkOrderId);
                devopsOrderInspectors.setInspectorsId(Integer.parseInt(inspectorsIdList[i]));
                devopsOrderInspectors.setCreator(user.getUserName());
                devopsOrderInspectors.setCreateTime(new Date());
                devopsOrderInspectors.setStatus(1);
                devopsOrderInspectorsService.save(devopsOrderInspectors);
            }
        }
    }

    @Override
    public void devopsWorkOrderDel(Integer id) {
        DevopsWorkOrder devopsWorkOrder = new DevopsWorkOrder();
        devopsWorkOrder.setId(id);
        devopsWorkOrder.setStatus(0);
        this.updateById(devopsWorkOrder);
        //巡检设备
        LambdaQueryWrapper<DevopsOrderDevice> queryWrapperOne = Wrappers.lambdaQuery();
        queryWrapperOne.eq(DevopsOrderDevice::getWorkOrderId, id).eq(DevopsOrderDevice::getStatus, 1);
        List<DevopsOrderDevice> devopsOrderDeviceList = devopsOrderDeviceService.list(queryWrapperOne);

        //人员
        LambdaQueryWrapper<DevopsOrderInspectors> queryWrapperTwo = Wrappers.lambdaQuery();
        queryWrapperTwo.eq(DevopsOrderInspectors::getWorkOrderId, id).eq(DevopsOrderInspectors::getStatus, 1);
        List<DevopsOrderInspectors> devopsOrderInspectorsList = devopsOrderInspectorsService.list(queryWrapperTwo);

        if (devopsOrderDeviceList.size() > 0) {
            for (int i = 0; i < devopsOrderDeviceList.size(); i++) {
                DevopsOrderDevice devopsOrderDevice = new DevopsOrderDevice();
                devopsOrderDevice.setId(devopsOrderDeviceList.get(i).getId());
                devopsOrderDevice.setStatus(0);
                devopsOrderDeviceService.updateById(devopsOrderDevice);
            }
        }

        if (devopsOrderInspectorsList.size() > 0) {
            for (int i = 0; i < devopsOrderInspectorsList.size(); i++) {
                DevopsOrderInspectors devopsOrderInspectors = new DevopsOrderInspectors();
                devopsOrderInspectors.setId(devopsOrderInspectorsList.get(i).getId());
                devopsOrderInspectors.setStatus(0);
                devopsOrderInspectorsService.updateById(devopsOrderInspectors);
            }
        }
    }

    @Override
    public void devopsOrderDeviceDel(Integer inspectionDeviceId) {
        DevopsOrderDevice devopsOrderDevice = new DevopsOrderDevice();
        devopsOrderDevice.setId(inspectionDeviceId);
        devopsOrderDevice.setStatus(0);
        devopsOrderDeviceService.updateById(devopsOrderDevice);
    }

    @Override
    public void devopsOrderInspectorsDel(Integer inspectorsId) {
        DevopsOrderInspectors devopsOrderInspectors = new DevopsOrderInspectors();
        devopsOrderInspectors.setId(inspectorsId);
        devopsOrderInspectors.setStatus(0);
        devopsOrderInspectorsService.updateById(devopsOrderInspectors);
    }


    @Override
    public CommonPage<DevopsWorkOrderListVo> devopsWorkOrderList(Integer generationMode, Integer workOrderStatus, Integer siteId, Integer inspectorsId, Integer size, Integer current) {
        List<DevopsWorkOrderListVo> devopsWorkOrderListTwo = new ArrayList<>();
        LambdaQueryWrapper<DevopsOrderInspectors> queryWrapperTwo = Wrappers.lambdaQuery();
        queryWrapperTwo.eq(DevopsOrderInspectors::getInspectorsId, inspectorsId).eq(DevopsOrderInspectors::getStatus, 1);
        List<DevopsOrderInspectors> devopsOrderInspectorsList = devopsOrderInspectorsService.list(queryWrapperTwo);

        List<DevopsWorkOrderListVo> devopsWorkOrderListOne = baseMapper.devopsWorkOrderList(generationMode, workOrderStatus, siteId, devopsOrderInspectorsList, null, 0);
        int total = 0;
        if (devopsWorkOrderListOne.size() > 0) {
            total = devopsWorkOrderListOne.size();
        }
        int startCurrent = (size - 1) * current;
        List<DevopsWorkOrderListVo> devopsWorkOrderList = baseMapper.devopsWorkOrderList(generationMode, workOrderStatus, siteId, devopsOrderInspectorsList, startCurrent, current);
        if (devopsWorkOrderList.size() > 0) {
            List<PatrolInspectorsVo> patrolInspectorsVoList = baseMapper.patrolInspectorsVoList(0);
            for (int i = 0; i < devopsWorkOrderList.size(); i++) {
                String inspectorsNameList = "";
                for (int j = 0; j < patrolInspectorsVoList.size(); j++) {
                    if (devopsWorkOrderList.get(i).getId() == patrolInspectorsVoList.get(j).getWorkOrderId()) {
                        inspectorsNameList = inspectorsNameList + patrolInspectorsVoList.get(j).getInspectorsName() + "，";
                    }
                    if (patrolInspectorsVoList.size() - 1 == j) {
                        inspectorsNameList = inspectorsNameList.substring(0, inspectorsNameList.length() - 1);
                    }
                }
                devopsWorkOrderList.get(i).setInspectorsName(inspectorsNameList);
//                devopsWorkOrderListTwo.set(i, devopsWorkOrderList.get(i));
            }
        }

        return new CommonPage<>(devopsWorkOrderList, total, current, size);
    }


    @Override
    public List<DevopsWorkOrderDetailsVo> devopsWorkOrderDetails(Integer id) {
        List<PatrolRouteContentListVo> patrolRouteContentListVoList = new ArrayList<>();
        List<DevopsWorkOrderDetailsVo> devopsWorkOrderList = baseMapper.devopsWorkOrderDetails(id);
        List<PatrolInspectorsVo> patrolInspectorsList = baseMapper.patrolInspectorsVoList(id);
        List<PatrolInspectionDeviceDetailsVo> PatrolInspectionDeviceList = baseMapper.patrolInspectionDeviceList(id);
        devopsWorkOrderList.get(0).setPatrolInspectionDeviceDetailsVo(PatrolInspectionDeviceList);
        devopsWorkOrderList.get(0).setPatrolInspectorsVo(patrolInspectorsList);

        if (devopsWorkOrderList.get(0).getGenerationMode() == 1) {
            LambdaQueryWrapper<PatrolInspectionRecord> queryWrapper = Wrappers.lambdaQuery();
            queryWrapper.eq(PatrolInspectionRecord::getId, devopsWorkOrderList.get(0).getInspectionRecordId());
            List<PatrolInspectionRecord> patrolInspectionRecordList = patrolInspectionRecordService.list(queryWrapper);
            List<PatrolRouteContentListVo> patrolRouteContentList = baseMapper.patrolRouteContentList(patrolInspectionRecordList.get(0).getSiteId(), patrolInspectionRecordList.get(0).getInspectionSchemeId());
            for (int i = 0; i < patrolRouteContentList.size(); i++) {
                LambdaQueryWrapper<PatrolRecordRoute> queryWrapperTwo = Wrappers.lambdaQuery();
                queryWrapperTwo.eq(PatrolRecordRoute::getInspectionRecordId, patrolInspectionRecordList.get(0).getId())
                        .eq(PatrolRecordRoute::getInspectionContentId, patrolRouteContentList.get(i).getInspectionContentId());
                List<PatrolRecordRoute> patrolInspectionSchemeList = patrolRecordRouteService.list(queryWrapperTwo);

                PatrolRouteContentListVo patrolRouteContentListVo = new PatrolRouteContentListVo();
                patrolRouteContentListVo.setId(patrolRouteContentList.get(i).getId());
                patrolRouteContentListVo.setInspectionRouteId(patrolRouteContentList.get(i).getInspectionRouteId());
                patrolRouteContentListVo.setInspectionContentId(patrolRouteContentList.get(i).getInspectionContentId());
                patrolRouteContentListVo.setInspectionContentName(patrolRouteContentList.get(i).getInspectionContentName());
                patrolRouteContentListVo.setInspectionDeviceName(patrolRouteContentList.get(i).getInspectionDeviceName());
                patrolRouteContentListVo.setCreator(patrolRouteContentList.get(i).getCreator());
                patrolRouteContentListVo.setCreateTime(patrolRouteContentList.get(i).getCreateTime());
                patrolRouteContentListVo.setStatus(patrolRouteContentList.get(i).getStatus());
                patrolRouteContentListVo.setPatrolRecordRoute(patrolInspectionSchemeList);
                List inspectionDeviceAbnormalList = new ArrayList();
                for (int j = 0; j < patrolInspectionSchemeList.size(); j++) {
                    inspectionDeviceAbnormalList.add(patrolInspectionSchemeList.get(j).getStatus());
                }
                patrolRouteContentListVoList.add(patrolRouteContentListVo);
            }

        }
        devopsWorkOrderList.get(0).setPatrolRouteContentListVoList(patrolRouteContentListVoList);

        return devopsWorkOrderList;
    }


    @Override
    public List<PatrolInspectors> patrolInspectorsDroplist() {
        SysUser user = SecurityUtils.getLoginUser().getUser();
        LambdaQueryWrapper<PatrolInspectors> queryWrapperTwo = Wrappers.lambdaQuery();
        queryWrapperTwo.eq(PatrolInspectors::getStatus, 1)
                .eq(PatrolInspectors::getUserId, user.getUserId());
        List<PatrolInspectors> patrolInspectorsList = patrolInspectorsService.list(queryWrapperTwo);
        return patrolInspectorsList;
    }

    @Override
    public List<PatrolInspectionTeamOneVo> PatrolInspectionTeamList() {
        List<PatrolInspectionTeamOneVo> patrolInspectionTeamOneVoList = new ArrayList<>();
        LambdaQueryWrapper<PatrolInspectionTeam> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(PatrolInspectionTeam::getStatus, 1);
        List<PatrolInspectionTeam> patrolInspectionTeamList = patrolInspectionTeamService.list(queryWrapper);
        List<PatrolInspectorsOneVo> patrolInspectorsOneVoList = baseMapper.patrolInspectorsOneVoList();
        if (patrolInspectionTeamList.size() > 0) {
            for (int i = 0; i < patrolInspectionTeamList.size(); i++) {
                List<Object> List = new ArrayList<>();
                PatrolInspectionTeamOneVo patrolInspectionTeamOneVo = new PatrolInspectionTeamOneVo();
                patrolInspectionTeamOneVo.setTeamType(patrolInspectionTeamList.get(i).getTeamType());
                patrolInspectionTeamOneVo.setInspectorsId(patrolInspectionTeamList.get(i).getInspectorsId());
                patrolInspectionTeamOneVo.setTeamName(patrolInspectionTeamList.get(i).getTeamName());
                patrolInspectionTeamOneVo.setCreator(patrolInspectionTeamList.get(i).getCreator());
                patrolInspectionTeamOneVo.setCreateTime(patrolInspectionTeamList.get(i).getCreateTime());
                patrolInspectionTeamOneVo.setStatus(patrolInspectionTeamList.get(i).getStatus());
                patrolInspectionTeamOneVo.setId(patrolInspectionTeamList.get(i).getId());
                patrolInspectionTeamOneVo.setUserId(patrolInspectionTeamList.get(i).getUserId());
                patrolInspectionTeamOneVo.setReservedField(patrolInspectionTeamList.get(i).getReservedField());

                if (patrolInspectorsOneVoList.size() > 0) {
                    for (int j = 0; j < patrolInspectorsOneVoList.size(); j++) {
                        if (patrolInspectionTeamList.get(i).getId() == patrolInspectorsOneVoList.get(j).getTeamId()) {
                            List.add(patrolInspectorsOneVoList.get(j));
                        }
                    }
                }
                patrolInspectionTeamOneVo.setPatrolInspectorsOneVo(List);

                patrolInspectionTeamOneVoList.add(patrolInspectionTeamOneVo);
            }
        }
        return patrolInspectionTeamOneVoList;
    }

    @Override
    public List<OpexStatisticsVo> operationCensus(String type) {
        String firstDay;
        String lastDay;
        Date startDate;
        Date endDate;
        String startTime;
        String endTime;
        int days = 0;
        SysUser user = SecurityUtils.getLoginUser().getUser();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat yearFormatter = new SimpleDateFormat("yyyy");
        Date date = new Date();
        String year = yearFormatter.format(date);
        String startHms = "00:00:00";
        String endHms = "23:59:59";
        Integer stayGrabOrdersCount = 0;
        Integer stayAppointCount = 0;
        Integer stayOrderTakingCount = 0;
        Integer stayManageCount = 0;
        Integer stayCustomsClearanceCount = 0;
        Integer completedCount = 0;

        switch (type) {
            case "thisMonth":
                Calendar calendar = new GregorianCalendar();
                calendar.setTime(date);
                //获得本月第一天
                calendar.add(Calendar.MONTH, 0);
                calendar.set(Calendar.DAY_OF_MONTH, 1);
                firstDay = sdf.format(calendar.getTime());
                startDate = calendar.getTime();
                //获得本月最后一天
                calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
                lastDay = sdf.format(calendar.getTime());
                startTime = firstDay + " " + startHms;
                endTime = lastDay + " " + endHms;
                days = (int) ((date.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;

                break;
            case "lastMonth":
                //获取前一个月第一天
                Calendar calendar1 = Calendar.getInstance();
                calendar1.add(Calendar.MONTH, -1);
                calendar1.set(Calendar.DAY_OF_MONTH, 1);
                firstDay = sdf.format(calendar1.getTime());
                startDate = calendar1.getTime();
                //获取前一个月最后一天
                Calendar calendar2 = Calendar.getInstance();
                calendar2.set(Calendar.DAY_OF_MONTH, 0);
                lastDay = sdf.format(calendar2.getTime());
                endDate = calendar2.getTime();
                startTime = firstDay + " " + startHms;
                endTime = lastDay + " " + endHms;

                days = (int) ((endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;
                break;
            case "thisQuarter":
                //获取本季度第一天
                startDate = getCurrentQuarterStartTime();
                firstDay = sdf.format(startDate);
                //获取本季度最后一天
                endDate = getCurrentQuarterEndTime();
                lastDay = sdf.format(endDate);
                startTime = firstDay + " " + startHms;
                endTime = lastDay + " " + endHms;
                days = (int) ((date.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;
                break;
            case "lastQuarter":
                startDate = getCurrentQuarterStartTime();
                endDate = getCurrentQuarterEndTime();
                Calendar calendar3 = Calendar.getInstance(); //得到日历
                calendar3.setTime(startDate);//把当前时间赋给日历
                calendar3.add(calendar3.MONTH, -3); //设置为前3月
                date = calendar3.getTime(); //得到前3月的时间
                firstDay = sdf.format(date);
                calendar3.setTime(endDate);//把当前时间赋给日历
                calendar3.add(calendar3.MONTH, -3); //设置为前3月
                date = calendar3.getTime(); //得到前3月的时间
                lastDay = sdf.format(date);
                startTime = firstDay + " " + startHms;
                endTime = lastDay + " " + endHms;
                days = (int) ((endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;
                break;
            case "thisYear":
                //获取本年时间
                startTime = year + "-01-01 " + startHms;
                endTime = year + "-12-31 " + endHms;

                try {
                    startDate = sdf.parse(year + "-01-01");
                    days = (int) ((date.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;
                } catch (ParseException e) {
                    e.printStackTrace();
                }

                break;
            case "lastYear":
                Calendar c = Calendar.getInstance();
                c.add(Calendar.YEAR, -1);
                Date yearDate = c.getTime();
                String yearTime = yearFormatter.format(yearDate);
                startTime = yearTime + "-01-01 " + startHms;
                endTime = yearTime + "-12-31 " + endHms;
                try {
                    startDate = sdf.parse(year + "-01-01");
                    endDate = sdf.parse(yearTime + "-12-31");
                    days = (int) ((endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                break;
            default:
                String[] time = type.split(",");
                startTime = time[0] + " " + startHms;
                endTime = time[1] + " " + endHms;
                try {
                    startDate = sdf.parse(time[0]);
                    endDate = sdf.parse(time[1]);
                    days = (int) ((endDate.getTime() - startDate.getTime()) / (1000 * 3600 * 24)) + 1;
                } catch (ParseException e) {
                    e.printStackTrace();
                }
        }


        //新建工单数量
        LambdaQueryWrapper<DevopsWorkOrder> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(DevopsWorkOrder::getStatus, 1)
                .between(DevopsWorkOrder::getCreateTime, startTime, endTime);
        Integer newWorkOrderCount = this.count(queryWrapper);

        //已完成工单
        LambdaQueryWrapper<DevopsWorkOrder> queryWrapperOne = Wrappers.lambdaQuery();
        queryWrapperOne.eq(DevopsWorkOrder::getStatus, 1)
                .eq(DevopsWorkOrder::getWorkOrderStatus, 6)
                .between(DevopsWorkOrder::getCreateTime, startTime, endTime);
        Integer completedWorkOrder = this.count(queryWrapperOne);

        //平均响应时间
        Double averageResponseTime = 0.30;

        //日均工单数
        double workOrderAveCount = newWorkOrderCount / days;

        //工作状态
        QueryWrapper<DevopsWorkOrder> queryWrapperTwo = new QueryWrapper<>();
        queryWrapperTwo.select("work_order_status", "count(*) as count")
                .eq("status", 1)
                .between("create_time", startTime, endTime)
                .groupBy("work_order_status");

        List<DevopsWorkOrder> groupingQueryVoList = this.list(queryWrapperTwo);
        for (int i = 0; i < groupingQueryVoList.size(); i++) {
            switch (groupingQueryVoList.get(i).getWorkOrderStatus()) {
                case 1:
                    stayGrabOrdersCount = groupingQueryVoList.get(i).getCount();
                    break;
                case 2:
                    stayAppointCount = groupingQueryVoList.get(i).getCount();
                    break;
                case 3:
                    stayOrderTakingCount = groupingQueryVoList.get(i).getCount();
                    break;
                case 4:
                    stayManageCount = groupingQueryVoList.get(i).getCount();
                    break;
                case 5:
                    stayCustomsClearanceCount = groupingQueryVoList.get(i).getCount();
                    break;
                case 6:
                    completedCount = groupingQueryVoList.get(i).getCount();
                    break;
                default:
            }
        }

        //各站点各类工单数统计
        QueryWrapper<DevopsWorkOrder> queryWrapperThree = new QueryWrapper<>();
        queryWrapperThree.select("site_id", "work_order_type", "count(*) as count")
                .eq("status", 1)
                .between("create_time", startTime, endTime)
                .groupBy("site_id", "work_order_type");
        List<DevopsWorkOrder> WorkOrderStatisticsList = this.list(queryWrapperThree);
        List<Object> workOrderStatistics = new ArrayList<>();
        List<Site> siteList = baseMapper.SiteList(user.getUserId().intValue(), null);
        if (siteList.size() > 0) {
            for (int i = 0; i < siteList.size(); i++) {
                Map<String, Object> map = new HashMap<>();
                Integer safetyValuationCount = 0;
                Integer overhaulCount = 0;
                Integer rushRepairCount = 0;
                Integer otherCount = 0;
                Integer maintainCount = 0;
                Integer outageMaintenanceCount = 0;
                Integer inspectionCount = 0;
                if (WorkOrderStatisticsList.size() > 0) {
                    for (int j = 0; j < WorkOrderStatisticsList.size(); j++) {
                        if (siteList.get(i).getId() == WorkOrderStatisticsList.get(j).getSiteId()) {
                            switch (WorkOrderStatisticsList.get(j).getWorkOrderType()) {
                                case 1:
                                    safetyValuationCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                case 2:
                                    overhaulCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                case 3:
                                    rushRepairCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                case 4:
                                    otherCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                case 5:
                                    maintainCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                case 6:
                                    outageMaintenanceCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                case 7:
                                    inspectionCount = WorkOrderStatisticsList.get(j).getCount();
                                    break;
                                default:
                            }
                        }
                        map.put("siteName", siteList.get(i).getSiteName());
                        map.put("safetyValuationCount", safetyValuationCount);
                        map.put("overhaulCount", overhaulCount);
                        map.put("rushRepairCount", rushRepairCount);
                        map.put("otherCount", otherCount);
                        map.put("maintainCount", maintainCount);
                        map.put("outageMaintenanceCount", outageMaintenanceCount);
                        map.put("inspectionCount", inspectionCount);
                    }
                } else {
                    map.put("siteName", siteList.get(i).getSiteName());
                    map.put("safetyValuationCount", safetyValuationCount);
                    map.put("overhaulCount", overhaulCount);
                    map.put("rushRepairCount", rushRepairCount);
                    map.put("otherCount", otherCount);
                    map.put("maintainCount", maintainCount);
                    map.put("outageMaintenanceCount", outageMaintenanceCount);
                    map.put("inspectionCount", inspectionCount);
                }
                workOrderStatistics.add(map);
            }
        }


        //工单数趋势
        QueryWrapper<DevopsWorkOrder> queryWrapperFour = new QueryWrapper<>();
        queryWrapperFour.select("FROM_UNIXTIME(UNIX_TIMESTAMP(create_time) , '%Y-%m-%d') as create_time", "count(*) as count")
                .eq("status", 1)
                .between("create_time", startTime, endTime)
                .groupBy("site_id", "work_order_type");
        List<DevopsWorkOrder> workOrderTrend = this.list(queryWrapperFour);

        List<OpexStatisticsVo> list = new ArrayList<>();
        list.add(OpexStatisticsVo.builder()
                .newWorkOrderCount(newWorkOrderCount)
                .completedWorkOrder(completedWorkOrder)
                .averageResponseTime(averageResponseTime)
                .workOrderAveCount(workOrderAveCount)
                .stayGrabOrdersCount(stayGrabOrdersCount)
                .stayAppointCount(stayAppointCount)
                .stayOrderTakingCount(stayOrderTakingCount)
                .stayManageCount(stayManageCount)
                .stayCustomsClearanceCount(stayCustomsClearanceCount)
                .completedCount(completedCount)
                .workOrderStatistics(workOrderStatistics)
                .workOrderTrend(workOrderTrend)
                .build());

        return list;

    }

    //根据当前日期获取本季度第一天
    public static Date getCurrentQuarterStartTime() {
        Calendar c = Calendar.getInstance();
        int currentMonth = c.get(Calendar.MONTH) + 1;
        SimpleDateFormat longSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat shortSdf = new SimpleDateFormat("yyyy-MM-dd");
        Date now = null;
        try {
            if (currentMonth <= 3)
                c.set(Calendar.MONTH, 0);
            else if (currentMonth <= 6)
                c.set(Calendar.MONTH, 3);
            else if (currentMonth <= 9)
                c.set(Calendar.MONTH, 6);
            else if (currentMonth <= 12)
                c.set(Calendar.MONTH, 9);
            c.set(Calendar.DATE, 1);
            now = longSdf.parse(shortSdf.format(c.getTime()) + " 00:00:00");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return now;
    }


    //根据当前日期获取本季度最后一天
    public static Date getCurrentQuarterEndTime() {
        Calendar cal = Calendar.getInstance();
        cal.setTime(getCurrentQuarterStartTime());
        cal.add(Calendar.MONTH, 2);
        cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
        cal.set(Calendar.HOUR_OF_DAY, 23);
        cal.set(Calendar.MINUTE, 59);
        cal.set(Calendar.SECOND, 59);
        cal.set(Calendar.MILLISECOND, 999);
        return cal.getTime();
    }

    @Override
    public CommonPage<ProcessingTimeVo> workloadStatisticsLits(Integer siteId,String startTime,String endTime,Integer size , Integer current){
        List<ProcessingTime> processingTimeList = baseMapper.workloadStatisticsLits(siteId, startTime, endTime);
        LambdaQueryWrapper<PatrolInspectors> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(PatrolInspectors::getStatus, 1);
        List<PatrolInspectors> patrolInspectorsList =  patrolInspectorsService.list(queryWrapper);
        List<ProcessingTimeVo> Active1 = new ArrayList<ProcessingTimeVo>(); // 存放页面需要展示的数据
        List<ProcessingTimeVo> processingTimeVoList1 = new ArrayList<>();

        if (patrolInspectorsList.size()>0){
            for (int i = 0; i < patrolInspectorsList.size(); i++) {
                ProcessingTimeVo processingTimeVo1 = new ProcessingTimeVo();
                Map<String, Object> map = new HashMap<>();
                Integer orderQuantity = 0;
                Integer completedQuantity = 0;
                Integer incomplete = 0;
                Integer responseTime = 0;
                Integer processingTime = 0;
                if (processingTimeList.size()>0){
                    for (Integer j = 0; j < processingTimeList.size(); j++) {
                        if (patrolInspectorsList.get(i).getId()==processingTimeList.get(j).getId()){
                            switch (processingTimeList.get(j).getWorkOrderStatus()) {
                                case 4:
                                    orderQuantity += processingTimeList.get(j).getCount();
                                    incomplete += processingTimeList.get(j).getCount();
                                    break;
                                case 5:
                                    incomplete += processingTimeList.get(j).getCount();
                                    orderQuantity += processingTimeList.get(j).getCount();
                                    break;
                                case 6:
                                    orderQuantity += processingTimeList.get(j).getCount();
                                    completedQuantity += processingTimeList.get(j).getCount();
                                    processingTime=processingTimeList.get(j).getProcessingTime();
                                    break;
                                default:
                            }
                        }
                    }

                    processingTimeVo1.setId(patrolInspectorsList.get(i).getId());
                    processingTimeVo1.setInspectorsName(patrolInspectorsList.get(i).getInspectorsName());
                    processingTimeVo1.setOrderQuantity(orderQuantity);
                    processingTimeVo1.setCompletedQuantity(completedQuantity);
                    processingTimeVo1.setIncomplete(incomplete);
                    processingTimeVo1.setResponseTime(responseTime);
                    processingTimeVo1.setProcessingTime(processingTime);
                    processingTimeVo1.setTestimonials("");
                }else {
                    processingTimeVo1.setId(patrolInspectorsList.get(i).getId());
                    processingTimeVo1.setInspectorsName(patrolInspectorsList.get(i).getInspectorsName());
                    processingTimeVo1.setOrderQuantity(orderQuantity);
                    processingTimeVo1.setCompletedQuantity(completedQuantity);
                    processingTimeVo1.setIncomplete(incomplete);
                    processingTimeVo1.setResponseTime(responseTime);
                    processingTimeVo1.setProcessingTime(processingTime);
                    processingTimeVo1.setTestimonials("");
                }

                processingTimeVoList1.add(processingTimeVo1);
            }
            int currIdx = (current > 1 ? (current -1) * size: 0);
            for (int i = 0; i < size && i < processingTimeVoList1.size() - currIdx; i++) { // 判断条件十分巧妙，防止List取值越界
                ProcessingTimeVo active = processingTimeVoList1.get(currIdx + i);
                Active1.add(active);
            }
        }
        return new CommonPage<>(Active1, processingTimeVoList1.size(), size, current);
    }

    @Override
    public String workloadStatisticsExport(Integer siteId,String startTime,String endTime){
        Workbook workbook = null;
        File file = null;
        try {
            ExportParams params = new ExportParams(null, "工作量统计");
            workbook = ExcelExportUtil.exportBigExcel(params, ProcessingTimeExportVO.class,
                    (o, i) -> {
                        List<ProcessingTime> processingTimeList = baseMapper.workloadStatisticsLits(siteId, startTime, endTime);
                        LambdaQueryWrapper<PatrolInspectors> queryWrapper = Wrappers.lambdaQuery();
                        queryWrapper.eq(PatrolInspectors::getStatus, 1);
                        List<PatrolInspectors> patrolInspectorsList =  patrolInspectorsService.list(queryWrapper);
                        List<ProcessingTimeVo> Active1 = new ArrayList<ProcessingTimeVo>(); // 存放页面需要展示的数据
                        List<ProcessingTimeVo> processingTimeVoList1 = new ArrayList<>();
                        if (patrolInspectorsList.size()>0){
                            for (int k = 0; k < patrolInspectorsList.size(); k++) {
                                ProcessingTimeVo processingTimeVo1 = new ProcessingTimeVo();
                                Map<String, Object> map = new HashMap<>();
                                Integer orderQuantity = 0;
                                Integer completedQuantity = 0;
                                Integer incomplete = 0;
                                Integer responseTime = 0;
                                Integer processingTime = 0;
                                if (processingTimeList.size()>0){
                                    for (Integer j = 0; j < processingTimeList.size(); j++) {
                                        if (patrolInspectorsList.get(k).getId()==processingTimeList.get(j).getId()){
                                            switch (processingTimeList.get(j).getWorkOrderStatus()) {
                                                case 4:
                                                    orderQuantity += processingTimeList.get(j).getCount();
                                                    incomplete += processingTimeList.get(j).getCount();
                                                    break;
                                                case 5:
                                                    incomplete += processingTimeList.get(j).getCount();
                                                    orderQuantity += processingTimeList.get(j).getCount();
                                                    break;
                                                case 6:
                                                    orderQuantity += processingTimeList.get(j).getCount();
                                                    completedQuantity += processingTimeList.get(j).getCount();
                                                    processingTime=processingTimeList.get(j).getProcessingTime();
                                                    break;
                                                default:
                                            }
                                        }
                                    }

                                    processingTimeVo1.setId(patrolInspectorsList.get(k).getId());
                                    processingTimeVo1.setInspectorsName(patrolInspectorsList.get(k).getInspectorsName());
                                    processingTimeVo1.setOrderQuantity(orderQuantity);
                                    processingTimeVo1.setCompletedQuantity(completedQuantity);
                                    processingTimeVo1.setIncomplete(incomplete);
                                    processingTimeVo1.setResponseTime(responseTime);
                                    processingTimeVo1.setProcessingTime(processingTime);
                                    processingTimeVo1.setTestimonials("");
                                }else {
                                    processingTimeVo1.setId(patrolInspectorsList.get(k).getId());
                                    processingTimeVo1.setInspectorsName(patrolInspectorsList.get(k).getInspectorsName());
                                    processingTimeVo1.setOrderQuantity(orderQuantity);
                                    processingTimeVo1.setCompletedQuantity(completedQuantity);
                                    processingTimeVo1.setIncomplete(incomplete);
                                    processingTimeVo1.setResponseTime(responseTime);
                                    processingTimeVo1.setProcessingTime(processingTime);
                                    processingTimeVo1.setTestimonials("");
                                }

                                processingTimeVoList1.add(processingTimeVo1);
                            }
                            int currIdx = (i > 1 ? (i -1) * 30: 0);
                            for (int j = 0; j < 30 && j < processingTimeVoList1.size() - currIdx; j++) { // 判断条件十分巧妙，防止List取值越界
                                ProcessingTimeVo active = processingTimeVoList1.get(currIdx + j);
                                Active1.add(active);
                            }
                        }
                        return new ArrayList<>(BeanMapperUtils.mapList(Active1, ProcessingTimeVo.class, ProcessingTimeExportVO.class));
                    }, null);
            if (null != workbook) {
                file = FileUtils.getFile(GlobalUtils.getTempBaseDir(), String.format("%s-%s.xlsx", "工作量统计", System.currentTimeMillis() + ""));
                FileUtils.createFile(file.getAbsolutePath());
                FileOutputStream allListingFileOutputStream = new FileOutputStream(file);
                workbook.write(allListingFileOutputStream);
            } else {
                throw new BusinessException("表格数据为空");
            }
        } catch (Exception e) {
            log.error("导出文件失败", e);
            throw new BusinessException("导出文件失败");
        } finally {
            if (workbook != null) {
                try {
                    workbook.close();
                } catch (IOException e) {
                    log.error("===export spec=== 关闭workbook失败", e);
                }
            }
        }
        return file.getName();
    }

}