工单，数据中心用户查看数据的权限，合同考核每日，以及导出每日和按月

zxl

4 天以前 f77a9d8f16bae6b4cf809891f037c038070e81ed

 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java

@@ -1,10 +1,6 @@
package com.ycl.platform.service.impl;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.ExcelWriter;
import com.alibaba.excel.write.metadata.WriteSheet;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@@ -12,14 +8,13 @@
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.util.StringUtil;
import com.ycl.config.PlatformConfig;
import com.ycl.exception.ServiceException;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.excel.ErrorExport;
import com.ycl.platform.domain.excel.PointExport;
import com.ycl.platform.domain.excel.WorkOrderWhiteExport;
import com.ycl.platform.domain.form.*;
import com.ycl.platform.domain.query.*;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.vo.*;
import com.ycl.platform.domain.vo.screen.ScreenWorkOrderVO;
import com.ycl.platform.domain.vo.screen.WorkOrderRegionVO;
@@ -32,20 +27,23 @@
import com.ycl.platform.wvp.WVPResult;
import com.ycl.system.Result;
import com.ycl.system.domain.SysConfig;
import com.ycl.system.entity.SysDept;
import com.ycl.system.entity.SysDictData;
import com.ycl.system.mapper.SysConfigMapper;
import com.ycl.system.model.LoginUser;
import com.ycl.system.page.PageUtil;
import com.ycl.system.service.ISysDeptService;
import com.ycl.task.DeleteWorkOrderImgTask;
import com.ycl.utils.DateUtils;
import com.ycl.utils.SecurityUtils;
import com.ycl.utils.http.HttpUtils;
import com.ycl.utils.redis.RedisCache;
import com.ycl.utils.uuid.IdUtils;
import constant.ApiConstants;
import constant.Constants;
import constant.RedisConstant;
import enumeration.ErrorType;
import enumeration.general.*;
import jakarta.servlet.http.HttpServletResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
@@ -66,9 +64,9 @@
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import pojo.CascadeOption;
import utils.file.FileUtils;

import java.io.IOException;
import java.io.OutputStream;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;
@@ -88,6 +86,9 @@
public class WorkOrderServiceImpl extends ServiceImpl<WorkOrderMapper, WorkOrder> implements WorkOrderService {

    private final YwPointService ywPointService;
    private final YwPointMapper ywPointMapper;
    private final TMonitorMapper monitorMapper;
    private final DynamicColumnMapper dynamicColumnMapper;
    private final WorkOrderAuditingRecordMapper workOrderAuditingRecordMapper;
    private final WorkOrderAuditingRecordService workOrderAuditingRecordService;
    private final WorkOrderYwConditionRecordMapper workOrderYwConditionRecordMapper;
@@ -109,6 +110,8 @@

    @Autowired
    private RedisCache redisCache;
    @Autowired
    private DeleteWorkOrderImgTask deleteWorkOrderImgTask;

    @Override
    public synchronized Boolean innerAddWorkOrder(List<WorkOrder> workOrderList) {
@@ -181,18 +184,18 @@
                    //避免代下发的工单直接变成下发
                    if (!databaseWorkOrder.getStatus().equals(WorkOrderStatusEnum.WAIT_DISTRIBUTE)) {
                        databaseWorkOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                        // 同时新增一个运维处理信息，表明此工单被调整
                        WorkOrderYwConditionRecord ywRecord = new WorkOrderYwConditionRecord();
                        ywRecord.setWorkOrderNo(databaseWorkOrder.getWorkOrderNo());
                        ywRecord.setCommitUser(1);
                        ywRecord.setYwCondition("故障类型更新，工单状态调整为待处理");
                        ywRecord.setCreateTime(new Date());
                        ywRecord.setSysMsg(Boolean.TRUE);
                        willAddMsg.add(ywRecord);
                    }
                    databaseWorkOrder.setUpdateTime(now);
                    willUpdateStatusWorkOrderList.add(databaseWorkOrder);
                    updateNum++;
                    // 同时新增一个运维处理信息，表明此工单被调整
                    WorkOrderYwConditionRecord ywRecord = new WorkOrderYwConditionRecord();
                    ywRecord.setWorkOrderNo(databaseWorkOrder.getWorkOrderNo());
                    ywRecord.setCommitUser(1);
                    ywRecord.setYwCondition("故障类型更新，工单状态调整为待处理");
                    ywRecord.setCreateTime(new Date());
                    ywRecord.setSysMsg(Boolean.TRUE);
                    willAddMsg.add(ywRecord);
                }
            } else {
                workOrder.setCreateTime(new Date());
@@ -220,8 +223,9 @@
        }
        List<String> willAddSerialNumber = waitAddList.stream().map(WorkOrder::getSerialNumber).collect(Collectors.toList());
        //只生成考核设备、且有运维单位的工单

        List<YwPoint> pointList = new LambdaQueryChainWrapper<>(ywPointService.getBaseMapper())
                .select(YwPoint::getUnitId, YwPoint::getSerialNumber, YwPoint::getImportantTag, YwPoint::getImportantTag, YwPoint::getProvinceTag, YwPoint::getImportantCommandImageTag)
                .select(YwPoint::getUnitId, YwPoint::getSerialNumber, YwPoint::getImportantTag, YwPoint::getImportantTag, YwPoint::getImportantCommandImageTag)
                .in(YwPoint::getSerialNumber, willAddSerialNumber)
                .eq(YwPoint::getExamineStatus, Boolean.TRUE)
                .isNotNull(YwPoint::getUnitId)
@@ -292,6 +296,7 @@
            }
            log.info("即将生成的工单:{}", workOrder);
        }

        redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
        redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
        // 保存工单和故障类型
@@ -333,41 +338,105 @@
        List<WorkOrder> data = new ArrayList<>();
        WorkOrder workOrder = WorkOrderForm.getEntityByForm(form, null);
        data.add(workOrder);
        //校验白名单并排除在白名单的故障类型
        data = checkWhite(data);
        if (CollectionUtils.isEmpty(data)) {
            return Result.error("该设备的故障类型在白名单中，不能添加工单");
        }
        WorkOrder entity = data.get(0);

        //查redis今日工单数量
        int workOrderNum = 0;
        //UUID作为value，保证上锁的线程自己解锁
        String requestId = IdUtils.fastSimpleUUID();
        boolean result = redisCache.acquireLock(RedisConstant.WORKORDER_NUM_LOCK, requestId, 10000);
        if (result) {
            //查今日工单量
            Object redisNum = redisCache.getCacheObject(RedisConstant.WORKORDER_NUM);
            workOrderNum = redisNum == null ? 0 : (Integer) redisNum;
            workOrderNum++;
            redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
            redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
        } else {
            return Result.error("工单正在添加，请稍后再试");
        }

        entity.setCreateTime(DateUtils.getNowDate());
        entity.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE);
        String serialNumber = entity.getSerialNumber();
        Date now = new Date();
        entity.setCreateTime(now);
        entity.setUpdateTime(now);
        entity.setWorkOrderNo(IdUtils.workOrderNO(now, String.format("%05d", workOrderNum)));
        entity.setErrorType(String.join(",", form.getErrorType()));
        List<WorkOrderErrorType> workOrderErrorTypes = form.getErrorType().stream().map(errorType -> new WorkOrderErrorType(entity.getWorkOrderNo(), errorType)).toList();
        workOrderErrorTypeService.getBaseMapper().insertWorkOrderErrorTypeList(workOrderErrorTypes);
        if (baseMapper.insert(entity) > 0) {
        List<WorkOrder> inDatabaseWorkOrderList = baseMapper.getNotFinishedWorkOrders(Arrays.asList(serialNumber));
        inDatabaseWorkOrderList.stream().forEach(item -> {
            if (StringUtils.hasText(item.getErrorType())) {
                item.setErrorTypeList(List.of(item.getErrorType().split(",")));
            } else {
                item.setErrorTypeList(new ArrayList<>(1));
            }
        });
        // 因故障类型不一致而要更新状态的工单
        List<WorkOrder> willUpdateStatusWorkOrderList = new ArrayList<>(48);
        // 更改工单类型而要增加的系统运维处理信息
        List<WorkOrderYwConditionRecord> willAddMsg = new ArrayList<>(48);
        // 即将要添加的错误类型
        List<WorkOrderErrorType> willAddErrorType = new ArrayList<>(96);
        if (!CollectionUtils.isEmpty(inDatabaseWorkOrderList)) {
            WorkOrder workOrderInDB = inDatabaseWorkOrderList.get(0);
            List<String> errorNameList = workOrderInDB.getErrorTypeList();
            List<String> errorTypes = entity.getErrorTypeList();
            if (errorNameList.containsAll(errorTypes)) {
                return Result.error("已有同种故障类型工单");
            } else {
                for (String errorType : errorTypes) {
                    if (!errorNameList.contains(errorType)) {
                        // 错误类型不一样，就新增一个错误类型，并且重置工单状态为待处理
                        WorkOrderErrorType workOrderErrorType = new WorkOrderErrorType();
                        workOrderErrorType.setWorkOrderNo(workOrderInDB.getWorkOrderNo());
                        workOrderErrorType.setCreateTime(now);
                        workOrderErrorType.setUpdateTime(now);
                        workOrderErrorType.setErrorName(errorType);
                        willAddErrorType.add(workOrderErrorType);
                    }
                }
                //避免代下发的工单直接变成下发
                if (!workOrderInDB.getStatus().equals(WorkOrderStatusEnum.WAIT_DISTRIBUTE)) {
                    workOrderInDB.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                    // 同时新增一个运维处理信息，表明此工单被调整
                    WorkOrderYwConditionRecord ywRecord = new WorkOrderYwConditionRecord();
                    ywRecord.setWorkOrderNo(workOrderInDB.getWorkOrderNo());
                    ywRecord.setCommitUser(1);
                    ywRecord.setYwCondition("故障类型更新，工单状态调整为待处理");
                    ywRecord.setCreateTime(new Date());
                    ywRecord.setSysMsg(Boolean.TRUE);
                    willAddMsg.add(ywRecord);
                }
                workOrderInDB.setUpdateTime(now);
                willUpdateStatusWorkOrderList.add(workOrderInDB);
                //修改故障类型
                if (willAddErrorType.size() > 0) {
                    workOrderErrorTypeService.getBaseMapper().addMany(willAddErrorType);
                }
                //增加运维情况
                if (willAddMsg.size() > 0) {
                    workOrderYwConditionRecordMapper.insertMany(willAddMsg);
                }
                //更改工单状态
                if (willUpdateStatusWorkOrderList.size() > 0) {
                    this.baseMapper.updateMany(willUpdateStatusWorkOrderList);
                }
            }
            return Result.ok("添加成功");
        } else {
            //数据库没有正在进行的工单
            //查redis今日工单数量
            int workOrderNum = 0;
            //UUID作为value，保证上锁的线程自己解锁
            String requestId = IdUtils.fastSimpleUUID();
            boolean result = redisCache.acquireLock(RedisConstant.WORKORDER_NUM_LOCK, requestId, 10000);
            if (result) {
                //查今日工单量
                Object redisNum = redisCache.getCacheObject(RedisConstant.WORKORDER_NUM);
                workOrderNum = redisNum == null ? 0 : (Integer) redisNum;
                workOrderNum++;
                redisCache.setCacheObject(RedisConstant.WORKORDER_NUM, workOrderNum);
                redisCache.releaseLock(RedisConstant.WORKORDER_NUM_LOCK, requestId);
            } else {
                return Result.error("工单正在添加，请稍后再试");
            }
            entity.setCreateTime(DateUtils.getNowDate());
            entity.setStatus(WorkOrderStatusEnum.WAIT_DISTRIBUTE);
            entity.setCreateTime(now);
            entity.setUpdateTime(now);
            entity.setWorkOrderNo(IdUtils.workOrderNO(now, String.format("%05d", workOrderNum)));
            entity.setErrorType(String.join(",", form.getErrorType()));
            List<WorkOrderErrorType> workOrderErrorTypes = form.getErrorType().stream().map(errorType -> new WorkOrderErrorType(entity.getWorkOrderNo(), errorType)).toList();
            workOrderErrorTypeService.getBaseMapper().insertWorkOrderErrorTypeList(workOrderErrorTypes);
            if (baseMapper.insert(entity) > 0) {
                return Result.ok("添加成功");
            } else {
                return Result.error("添加失败");
            }
        }
        return Result.error("添加失败");
    }


@@ -413,10 +482,25 @@
                UrgentLevelEnum.WARNING,
                workOrder.getWorkOrderNo());
        notifyService.save(notify);
        List<WorkOrderVO> workOrderVOS = workOrderErrorTypeMapper.getErrorListByNumbers(Arrays.asList(workOrder.getWorkOrderNo()));

        // 同步点位状态
        if (form.getAuditingResult() == WorkOrderStatusEnum.AUDITING_SUCCESS) {
            ywPointService.updateRecovery(Collections.singletonList(workOrder.getSerialNumber()), 0);
            //如果工单为离线工单那么修改点位pingOnline为在线
            if (!CollectionUtils.isEmpty(workOrderVOS)) {
                List<String> ips = new ArrayList<>();
                for (WorkOrderVO workOrderVO : workOrderVOS) {
                    if(ErrorType.DEVICE_OFFLINE.getValue().equals(workOrderVO.getErrorType())){
                        ips.add(workOrderVO.getIp());
                    }
                }
                if(!CollectionUtils.isEmpty(ips)) {
                    monitorMapper.batchUpdateOnline(ips, new Date(), ApiConstants.UY_OnlineSite_Online);
                }
            }
        }

        return Result.ok("操作成功");
    }

@@ -456,11 +540,30 @@
                    workOrder.getWorkOrderNo());
            notifies.add(notify);
        }
        notifyService.saveBatch(notifies);
        // 同步点位状态
        if (form.getAuditingResult() == WorkOrderStatusEnum.AUDITING_SUCCESS) {
            ywPointService.updateRecovery(serialNumbers, 0);
            //筛选出离线工单ip并修改在线状态
            if (!CollectionUtils.isEmpty(serialNumbers)) {
                Map<String, List<String>> errorTypes = workOrderErrorTypeMapper.getErrorListByNumbers(workOrderNoList).stream().collect(Collectors.groupingBy(
                        WorkOrderVO::getIp,
                        Collectors.mapping(
                                WorkOrderVO::getErrorType,
                                Collectors.toList()
                        )
                ));
                List<String> ips = new ArrayList<>();
                errorTypes.forEach((key, value) -> {
                    if (!CollectionUtils.isEmpty(value) && value.contains(ErrorType.DEVICE_OFFLINE.getValue())) {
                        ips.add(key);
                    }
                });
                if(!CollectionUtils.isEmpty(ips)) {
                    monitorMapper.batchUpdateOnline(ips, new Date(), ApiConstants.UY_OnlineSite_Online);
                }
            }
        }
        notifyService.saveBatch(notifies);
        return Result.ok("操作成功");
    }

@@ -490,6 +593,37 @@
        return Result.ok("操作成功");
    }

    @Override
    public Result ywConditionList(WorkOrderYWConditionsForm form) {
        List<WorkOrder> workOrderList = new LambdaQueryChainWrapper<>(baseMapper)
                .in(WorkOrder::getWorkOrderNo,form.getWorkOrderNumbers())
                .list();
        System.out.println("--------------");
        System.out.println(workOrderList);
        if (CollectionUtils.isEmpty(workOrderList)) {
            throw new ServiceException("工单不存在");
        }
        // 工单状态
        for (WorkOrder workOrder : workOrderList) {
            workOrder.setStatus(WorkOrderStatusEnum.YW_HANDLE);
            workOrder.setYwHandleTime(LocalDateTime.now());
        }
        baseMapper.updateMany(workOrderList);
        // 添加一条运维情况记录
        for (WorkOrder workOrder : workOrderList) {
            WorkOrderYwConditionRecord workOrderYwConditionRecord = new WorkOrderYwConditionRecord();
            workOrderYwConditionRecord.setWorkOrderNo(workOrder.getWorkOrderNo());
            workOrderYwConditionRecord.setCommitUser(SecurityUtils.getLoginUser().getUserId().intValue());
            workOrderYwConditionRecord.setYwCondition(form.getYwCondition());
            workOrderYwConditionRecord.setYwProofMaterials(form.getYwProofMaterials());
            workOrderYwConditionRecord.setSysMsg(Boolean.FALSE);
            workOrderYwConditionRecordMapper.insert(workOrderYwConditionRecord);
            WorkOrderServiceImpl self = applicationContext.getBean(WorkOrderServiceImpl.class);
            self.getImage(workOrder);
        }
        return Result.ok("操作成功");
    }

    @Async("threadPoolTaskExecutor")
    public void getImage(WorkOrder workOrder) {
        List<DeviceInfo> gbDevices = new LambdaQueryChainWrapper<>(deviceInfoMapper)
@@ -512,9 +646,41 @@
            img.setWorkOrderNo(workOrder.getWorkOrderNo());
            img.setImgUrl(frameImg);
            img.setCreateTime(new Date());
            //保留最新的5张
            workOrderCheckImgMapper.insert(img);
        }
    }

    /**
     * 清理工单图片
     * */
    public void clearWorkOrderImg(String workOrderNo) {
        //判断该工单的图片是否已经大于5张了
        //按照创建日期降序排列
        if (StringUtil.isEmpty(workOrderNo)) {
            return;
        }
        List<WorkOrderCheckImg> workOrderList = new LambdaQueryChainWrapper<WorkOrderCheckImg>(workOrderCheckImgMapper)
                .select()
                .eq(WorkOrderCheckImg::getWorkOrderNo, workOrderNo)
                .orderByDesc(WorkOrderCheckImg::getCreateTime)
                .list();
        if (workOrderList.size()>=5){
            List<String> imgList = workOrderList.subList(4,workOrderList.size()).stream().map(WorkOrderCheckImg::getImgUrl).collect(Collectors.toList());
            List<Integer> idList = workOrderList.subList(4, workOrderList.size()).stream().map(WorkOrderCheckImg::getId).collect(Collectors.toList());
            //删除照片 ，并且物理删除服务器内对应照片的名字

//                /profile/2024-11-18_1d8e6d37-a4d0-4bba-8473-ff4e50eda83d.png
            log.error("删除工单照片集合url:{}",imgList);
            log.error("删除工单存储数据集合id:{}",idList);
            for (String filePath: imgList){
                delImgFormClient(filePath);
            }
            workOrderCheckImgMapper.deleteBatchIds(idList);
        }

    }


    @Override
    public List<WorkOrderYwConditionRecordVO> selectYwConditionByYwId(String workOrderNo) {
@@ -557,9 +723,29 @@
    @Override
    public Result remove(List<String> ids) {
        if (baseMapper.deleteBatchIds(ids) > 0) {
            //批量删除是否被用到?

            return Result.ok("删除成功");
        }
        return Result.error("删除失败");
    }

    /***
     * 通过url删除服务器内的图片
     * @param url
     */
    public void delImgFormClient(String url){
        //提取文件名  /profile/2024-11-17_79c02666-da1e-45ba-9f29-7523c848fa4a.png
        // 这部分2024-11-17_79c02666-da1e-45ba-9f29-7523c848fa4a.png
        String imgPath = FileUtils.getImgName(url);
        if (imgPath.isEmpty()){
            log.error("url错误：{}",imgPath);
        }else{
            //提取日期部分 组装目录 : /opt/zgyw/uploadPath  + /  + yyyy-MM-dd +
            String pathName = DeleteWorkOrderImgTask.imgSaveBasePath + "/" + FileUtils.extractDateFromString(url);
            log.error("删除工单图片集合{}",pathName+"/" + imgPath);
            FileUtils.deleteFile(pathName+"/" + imgPath);
        }
    }

    /**
@@ -574,6 +760,18 @@
        String workOrderNo = workOrder.getWorkOrderNo();
        //删除工单审核记录
        workOrderAuditingRecordMapper.delete(new QueryWrapper<WorkOrderAuditingRecord>().eq("work_order_no", workOrderNo));
        //需要物理删除服务器中的图片
        //查询到工单照片集合
        List<String> workOrderImg = workOrderCheckImgMapper
                .selectList(new QueryWrapper<WorkOrderCheckImg>().eq("work_order_no", workOrderNo))
                .stream().map(WorkOrderCheckImg::getImgUrl).collect(Collectors.toList());
        log.error("删除工单图片集合:{}",workOrderImg);
        log.error("删除路径:{}",PlatformConfig.getUploadPath());

        for (String filePath: workOrderImg){
            delImgFormClient(filePath);
        }

        //删除工单图片记录
        workOrderCheckImgMapper.delete(new QueryWrapper<WorkOrderCheckImg>().eq("work_order_no", workOrderNo));
        //删除工单下发记录
@@ -589,6 +787,9 @@
        return Result.error("删除失败");
    }



    private final ISysDeptService deptService;
    /**
     * 分页查询
     *
@@ -597,12 +798,44 @@
     */
    @Override
    public Result page(WorkOrderQuery query) {
        LoginUser loginUser = SecurityUtils.getLoginUser();
        SysDept sysDept = null;
        Long deptId =null;
        if (loginUser.getDeptId() != null){
            deptId = loginUser.getDeptId();
            sysDept = deptService.selectDeptById(deptId);
        }
        //查询指定区数据
        // 登录账号的存在部门 不在部门内就不传值，默认查询全部
        if (sysDept !=null){
            //更具部门id获得对应枚举 部门code
            AreaDeptEnum areaDeptEnum = AreaDeptEnum.fromDept(Math.toIntExact(sysDept.getDeptId()));
            if (areaDeptEnum != null){
                query.setDept(areaDeptEnum.getCode());
            }
        }


        IPage<WorkOrderVO> page = PageUtil.getPage(query, WorkOrderVO.class);
        if (query.getUnitId() == null) {
            query.setUnitId(SecurityUtils.getUnitId());
        }
        if (query.getStart() != null) query.setStart(DateUtils.getDayStart(query.getStart()));
        if (query.getEnd() != null) query.setEnd(DateUtils.getDayEnd(query.getEnd()));
        if (query.getErrorType() != null) {
            List<String> errorTypeList = new ArrayList<>();
            errorTypeList.add(query.getErrorType());
            if (ErrorType.ABNORMAL_PIC.getValue().equals(query.getErrorType())) {
                //List添加之前几种工单类型
                errorTypeList.add(ErrorType.SIGNAL_LOSS.getValue());
                errorTypeList.add(ErrorType.SCREEN_COLOR_DEVIATION.getValue());
                errorTypeList.add(ErrorType.SNOW_STORM.getValue());
                errorTypeList.add(ErrorType.STRIPE_INTERFERENCE.getValue());
                errorTypeList.add(ErrorType.SCREEN_OCCLUSION.getValue());
                errorTypeList.add(ErrorType.ABNORMAL_CLARITY.getValue());
            }
            query.setErrorTypeList(errorTypeList);
        }
        baseMapper.page(page, query);
        if (!CollectionUtils.isEmpty(page.getRecords())) {
            page.getRecords().stream().forEach(item -> {
@@ -635,6 +868,11 @@
        if (query.getEnd() != null) query.setEnd(DateUtils.getDayEnd(query.getEnd()));
        baseMapper.distributePage(page, query);
        return Result.ok().data(page).total(page.getTotal());
    }

    @Override
    public List<WorkOrderVO> distributeList(){
        return  baseMapper.distributeList();
    }

    @Override
@@ -694,6 +932,9 @@
        }
    }




    @Override
    @Transactional
    public Result selectedIdsDistribute(DistributeWorkOrderQuery query) {
@@ -702,6 +943,7 @@
            return Result.error("此刻有人下发中，为避免冲突，请稍后重试");
        }
        try {
            //这是全部下发
            if (query.getWorkOrderNOList().isEmpty()) {
                query.setWorkOrderNOList(new LambdaQueryChainWrapper<>(baseMapper)
                        .eq(WorkOrder::getStatus, WorkOrderStatusEnum.WAIT_DISTRIBUTE)
@@ -1039,6 +1281,11 @@
    @Override
    public Result detailByNo(String workOrderNo) {
        WorkOrderDetailVO workOrder = baseMapper.detailByNo(workOrderNo);
        //报空原因1. sql 中 inner join 表 t_work_order_distribute_record 中 无与该表关联的记录 wo.work_order_no = dr.work_order_no
        if(workOrder == null){
            workOrder = baseMapper.detailByNoButNoDistributeRecord(workOrderNo);
        }

        // 是否报备
        boolean hasReport = new LambdaQueryChainWrapper<>(reportMapper)
                .eq(Report::getSerialNumber, workOrder.getSerialNumber())
@@ -1048,6 +1295,8 @@
        List<SysDictData> errorList = workOrderErrorTypeService.getBaseMapper().getErrorList(workOrder.getWorkOrderNo());
        List<String> errList = errorList.stream().map(SysDictData::getDictLabel).collect(Collectors.toList());
        workOrder.setErrorTypeList(errList);
        //详情时再次清理
        clearWorkOrderImg(workOrderNo);
        // 检测图片
        List<WorkOrderCheckImg> imgList = new LambdaQueryChainWrapper<>(workOrderCheckImgMapper)
                .eq(WorkOrderCheckImg::getWorkOrderNo, workOrderNo)
@@ -1058,6 +1307,16 @@
        return Result.ok().data(workOrder);
    }

    @Autowired
    private WorkOrderMapper workOrderMapper;

    /**
     * 工单导出的逻辑
     * 标签：同一个ip标签合在一起，针对离线工单（ip相同就不会生成工单），方便运维处理
     *
     * @param query
     * @return
     */
    @Override
    public List<WorkOrderVO> export(WorkOrderExportQuery query) {
        if (query.getUnitId() == null) {
@@ -1065,8 +1324,105 @@
        }
        if (query.getStart() != null) query.setStart(query.getStart() + " 00:00:00");
        if (query.getEnd() != null) query.setEnd(query.getEnd() + " 23:59:59");
        if (query.getErrorType() != null) {
            List<String> errorTypeList = new ArrayList<>();
            errorTypeList.add(query.getErrorType());
            if (ErrorType.ABNORMAL_PIC.getValue().equals(query.getErrorType())) {
                //List添加之前几种工单类型
                errorTypeList.add(ErrorType.SIGNAL_LOSS.getValue());
                errorTypeList.add(ErrorType.SCREEN_COLOR_DEVIATION.getValue());
                errorTypeList.add(ErrorType.SNOW_STORM.getValue());
                errorTypeList.add(ErrorType.STRIPE_INTERFERENCE.getValue());
                errorTypeList.add(ErrorType.SCREEN_OCCLUSION.getValue());
                errorTypeList.add(ErrorType.ABNORMAL_CLARITY.getValue());
            }
            query.setErrorTypeList(errorTypeList);
        }
        List<WorkOrderVO> export = baseMapper.export(query);

        return baseMapper.export(query);

        List<String> workOrderNos = export.stream().map(WorkOrderVO::getWorkOrderNo).collect(Collectors.toList());
        List<WorkOrderVO> auditTimeList = workOrderMapper.getAuditTimeList(workOrderNos);
        Map<String, List<Date>> auditTimeMap = auditTimeList.stream()
                .collect(Collectors.groupingBy(
                        WorkOrderVO::getWorkOrderNo, // 分组的键
                        Collectors.mapping(WorkOrderVO::getAuditTime, Collectors.toList())));
        if (!CollectionUtils.isEmpty(workOrderNos)){
           export.forEach(workOrderVO -> {
               List<Date> auditTimes = auditTimeMap.get(workOrderVO.getWorkOrderNo());
               if (!CollectionUtils.isEmpty(auditTimes)){
                   //审核通过时间
                   Date passTime = Collections.max(auditTimes);
                   ZoneId zoneId = ZoneId.systemDefault();
                   workOrderVO.setPassTime(passTime.toInstant().atZone(zoneId).toLocalDateTime());
               }
           });
        }





        if (CollectionUtils.isEmpty(export)) return new ArrayList<WorkOrderVO>();
        List<String> ips = export.stream().map(WorkOrderVO::getIp).collect(Collectors.toList());
        //查出相同ip的设备、并查出标签
        List<TMonitorResult> monitorVOS = monitorMapper.getByIp(ips);
        //获取动态列数据
        List<Integer> pointIds = monitorVOS.stream().map(TMonitorResult::getPointId).collect(Collectors.toList());
        List<DynamicColumnVO> dynamics = dynamicColumnMapper.getDynamicsByIds("t_yw_point", pointIds);
        //补充动态列数据
        if (!CollectionUtils.isEmpty(dynamics)) {
            Map<Integer, List<DynamicColumnVO>> map = dynamics.stream().collect(Collectors.groupingBy(DynamicColumnVO::getRefId));
            for (TMonitorResult tMonitorResult : monitorVOS) {
                Integer pointId = tMonitorResult.getPointId();
                tMonitorResult.setDynamicColumnList(map.get(pointId));
            }
        }
        export.forEach(result -> {
            StringBuilder dynamicTag = new StringBuilder("");
            Boolean provinceTagVideo = false;
            Boolean provinceTagCar = false;
            Boolean provinceTagFace = false;
            Boolean importantTag = false;
            Boolean importantCommandImageTag = false;
            Boolean deptTag = false;
            List<String> dynamicTags = new ArrayList<>();
            for (TMonitorResult tagVO : monitorVOS) {
                //省厅标签通过ip判断 (运维要求)
                if (tagVO.getIp().equals(result.getIp())) {
                    if (tagVO.getProvinceTagVideo()) provinceTagVideo = true;
                    if (tagVO.getProvinceTagCar()) provinceTagCar = true;
                    if (tagVO.getProvinceTagFace()) provinceTagFace = true;
                    if (tagVO.getImportantTag()) importantTag = true;
                    if (tagVO.getImportantCommandImageTag()) importantCommandImageTag = true;
                    if (tagVO.getDeptTag()) deptTag = true;
                }
                //动态列根据国标判断
                if (tagVO.getNo().equals(result.getSerialNumber())) {
                    //动态列处理加在标签里
                    if (!CollectionUtils.isEmpty(tagVO.getDynamicColumnList())) {
                        List<DynamicColumnVO> dynamicColumnList = tagVO.getDynamicColumnList();
                        for (DynamicColumnVO dynamicColumnVO : dynamicColumnList) {
                            if (!dynamicTags.contains(dynamicColumnVO.getColumnValue()))
                                dynamicTags.add(dynamicColumnVO.getColumnValue());
                        }
                    }
                }
            }
            for (String tag : dynamicTags) {
                dynamicTag.append(tag).append("、");
            }
            StringBuilder tag = new StringBuilder("" + (provinceTagVideo ? "省厅视频、" : "") + (provinceTagCar ? "省厅车辆、" : "") + (provinceTagFace ? "省厅人脸、" : "") + (importantTag ? "重点点位、" : "") + (importantCommandImageTag ? "重点指挥图像、" : "") + (deptTag ? "部级、" : ""));
            if (tag.toString().endsWith("、")) {
                tag = new StringBuilder(tag.substring(0, tag.length() - 1));
            }
            if (dynamicTag.toString().endsWith("、")) {
                dynamicTag = new StringBuilder(dynamicTag.substring(0, dynamicTag.length() - 1));
            }
            result.setTag(tag.toString());
            result.setDynamicTag(dynamicTag.toString());
        });
        return export;
    }

    /**