配置文件

xiangpei

2024-08-15 eb6d97037cade9ecc2fca11ccd33cb6d1682d033

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

@@ -21,16 +21,15 @@
import com.ycl.platform.service.WorkOrderService;
import com.ycl.platform.service.YwPointService;
import com.ycl.system.Result;
import com.ycl.system.domain.SysConfig;
import com.ycl.system.mapper.SysConfigMapper;
import com.ycl.system.model.LoginUser;
import com.ycl.system.page.PageUtil;
import com.ycl.utils.DateUtils;
import com.ycl.utils.SecurityUtils;
import com.ycl.utils.redis.RedisCache;
import com.ycl.utils.uuid.IdUtils;
import enumeration.general.NotifyTypeEnum;
import enumeration.general.UrgentLevelEnum;
import enumeration.general.WorkOrderDistributeWayEnum;
import enumeration.general.WorkOrderStatusEnum;
import enumeration.general.*;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
@@ -39,6 +38,7 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.time.LocalDateTime;
@@ -65,6 +65,7 @@
    private final NotifyService notifyService;
    private final WorkOrderDistributeRecordMapper workOrderDistributeRecordMapper;
    private final TMonitorMapper monitorMapper;
    private final SysConfigMapper configMapper;

    private final String DISTRIBUTE_LOCK_KEY = "distributeLock";
    private final static String IMPORTANT = "important";
@@ -73,16 +74,91 @@
    private RedisCache redisCache;

    @Override
    public Boolean innerAdd(List<WorkOrder> workOrderList) {
    @Transactional(rollbackFor = Exception.class)
    public Boolean innerAddWorkOrder(List<WorkOrder> workOrderList) {
        int total = workOrderList.size();
        workOrderList.stream().filter(item -> {
            return StringUtils.hasText(item.getSerialNumber()) && Objects.nonNull(item.getStatus()) && StringUtils.hasText(item.getErrorType());
        });
        // TODO 自动下发工单
        int real = workOrderList.size();
        boolean result = this.saveBatch(workOrderList);
        log.info("传入工单总数: {}，实际添加工单数：{}", total, real);
        return result;
        if (CollectionUtils.isEmpty(workOrderList)) {
            return Boolean.TRUE;
        }
        List<String> serialNumberList = workOrderList.stream().map(WorkOrder::getSerialNumber).collect(Collectors.toList());
        // 查出数据库中国标码对应的未完成的工单
        List<WorkOrder> inDatabaseWorkOrderList = new LambdaQueryChainWrapper<>(baseMapper)
                .select(WorkOrder::getId, WorkOrder::getSerialNumber, WorkOrder::getStatus, WorkOrder::getErrorType)
                .in(WorkOrder::getSerialNumber, serialNumberList)
                .ne(WorkOrder::getStatus, WorkOrderStatusEnum.AUDITING_SUCCESS)
                .list();
        Map<String, WorkOrder> mapping = inDatabaseWorkOrderList.stream().collect((Collectors.toMap(WorkOrder::getSerialNumber, workOrder -> workOrder)));
        List<WorkOrder> waitAddList = new ArrayList<>(48);
        Integer updateNum = 0;
        for (WorkOrder workOrder : workOrderList) {
            WorkOrder databaseWorkOrder = mapping.get(workOrder.getSerialNumber());
            if (Objects.nonNull(databaseWorkOrder)) {
                String errorType = databaseWorkOrder.getErrorType();
                if (workOrder.getErrorType().equals(errorType)) {
                    // 如果，国标码、故障类型都一样，则跳过不处理
                    continue;
                } else {
                    // 错误类型不一样，就更新错误类型，并且重置工单状态为待处理
                    errorType = errorType + "," + workOrder.getErrorType();
                    databaseWorkOrder.setErrorType(errorType);
                    databaseWorkOrder.setStatus(WorkOrderStatusEnum.DISTRIBUTED);
                    baseMapper.updateById(databaseWorkOrder);
                    updateNum++;
                    // 同时新增一个运维处理信息，表明此工单被调整 TODO
                }
            } else {
                waitAddList.add(workOrder);
            }
        }
        if (CollectionUtils.isEmpty(waitAddList)) {
            return Boolean.TRUE;
        }
        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)
                .in(YwPoint::getSerialNumber, willAddSerialNumber)
                .list();
        Map<String, YwPoint> pointMapping = pointList.stream().collect(Collectors.toMap(YwPoint::getSerialNumber, point -> point));
        // 查出重点点位、普通点位的处理时间
        SysConfig important = configMapper.checkConfigKeyUnique("important.wordkorder.time");
        SysConfig normal = configMapper.checkConfigKeyUnique("normal.wordkorder.alarm.time");
        // 如果即将生成工单，但是设备国标码查不到点位，则不添加？
        List<WorkOrder> notAddList = new ArrayList<>();
        for (WorkOrder workOrder : waitAddList) {
            YwPoint point = pointMapping.get(workOrder.getSerialNumber());
            if (Objects.isNull(point)) {
                notAddList.add(workOrder);
                continue;
            }
            workOrder.setWorkOrderNo(IdUtils.timeAddRandomNO(5));
            workOrder.setUnitId(Math.toIntExact(point.getUnitId()));
            if (point.getImportantTag() || point.getImportantCommandImageTag()) {
                workOrder.setProcessingPeriod(Integer.valueOf(important.getConfigValue()));
            } else {
                workOrder.setProcessingPeriod(Integer.valueOf(normal.getConfigValue()));
            }
        }
        waitAddList.removeAll(notAddList);
        if (CollectionUtils.isEmpty(waitAddList)) {
            return Boolean.TRUE;
        }
        this.saveBatch(waitAddList);
        // 如果是直接下发，添加下发记录
        if (WorkOrderStatusEnum.DISTRIBUTED.equals(waitAddList.get(0).getStatus())) {
            List<WorkOrderDistributeRecord> distributedRecordList = waitAddList.stream().map(item -> {
                WorkOrderDistributeRecord workOrderDistributeRecord = new WorkOrderDistributeRecord();
                workOrderDistributeRecord.setWorkOrderId(item.getId());
                workOrderDistributeRecord.setDistributeWay(WorkOrderDistributeWayEnum.DIRECT_DISTRIBUTE);
                workOrderDistributeRecord.setUserId(1L);
                return workOrderDistributeRecord;
            }).collect(Collectors.toList());
            workOrderDistributeRecordMapper.insertBatch(distributedRecordList);
        }
        log.info("传入工单总数: {}，实际添加工单数：{}, 实际修改工单数：{}", total, waitAddList.size(), updateNum);
        return Boolean.TRUE;
    }

    /**
@@ -280,11 +356,6 @@
    public Result distributePage(DistributeWorkOrderQuery query) {
        IPage<WorkOrderVO> page = PageUtil.getPage(query, WorkOrderVO.class);
        baseMapper.distributePage(page, query);
        page.getRecords().stream().forEach(workOrder -> {
            if (StringUtils.hasText(workOrder.getPointTag()) && workOrder.getPointTag().contains(IMPORTANT)) {
                workOrder.setImportant(Boolean.TRUE);
            }
        });
        return Result.ok().data(page).total(page.getTotal());
    }