blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
龚焕茏
2024-04-18 b43ede1ee201c0d6aaede56e0fa3c4894c892e3c 
 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java


@@ -1,38 +1,43 @@


package com.ycl.platform.service.impl;




import com.baomidou.mybatisplus.core.metadata.IPage;


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.ycl.exception.ServiceException;


import com.ycl.platform.domain.entity.*;


import com.ycl.platform.domain.form.*;


import com.ycl.platform.domain.query.DistributeWorkOrderQuery;


import com.ycl.platform.domain.query.WorkOrderQuery;


import com.ycl.platform.domain.vo.DistributeWorkOrderVO;


import com.ycl.platform.domain.vo.WorkOrderVO;


import com.ycl.platform.mapper.*;


import com.ycl.platform.service.NotifyService;


import com.ycl.platform.service.WorkOrderService;


import com.ycl.system.Result;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.ycl.platform.domain.vo.WorkOrderVO;


import com.ycl.platform.domain.query.WorkOrderQuery;


import java.util.List;




import com.baomidou.mybatisplus.core.metadata.IPage;


import com.ycl.system.model.LoginUser;


import com.ycl.system.page.PageUtil;


import com.ycl.utils.DateUtils;


import com.ycl.utils.SecurityUtils;


import enumeration.general.FastDistributeTypeEnum;


import com.ycl.utils.redis.RedisCache;


import enumeration.general.NotifyTypeEnum;


import enumeration.general.WorkOrderDistributeWayEnum;


import enumeration.general.WorkOrderStatusEnum;


import org.springframework.stereotype.Service;


import lombok.RequiredArgsConstructor;


import org.apache.commons.lang3.ArrayUtils;


import org.springframework.beans.BeanUtils;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;


import org.springframework.util.Assert;


import java.util.ArrayList;


import java.util.Objects;


import java.util.stream.Collectors;




import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;


import lombok.RequiredArgsConstructor;


import org.springframework.util.StringUtils;




import java.time.LocalDateTime;


import java.time.ZoneId;


import java.util.List;


import java.util.Objects;


import java.util.concurrent.TimeUnit;


import java.util.stream.Collectors;




/**


 * 工单 服务实现类


@@ -50,7 +55,12 @@


    private final WorkOrderAuditingRecordMapper workOrderAuditingRecordMapper;


    private final WorkOrderYwConditionRecordMapper workOrderYwConditionRecordMapper;


    private final NotifyService notifyService;


    private final WorkOrderDistributeRecordMapper workOrderDistributeRecordMapper;




    private final String DISTRIBUTE_LOCK_KEY = "distributeLock";




    @Autowired


    private RedisCache redisCache;




    /**


     * 添加


@@ -104,8 +114,12 @@


        workOrderAuditingRecord.setRemark(form.getAuditingRemark());


        workOrderAuditingRecordMapper.insert(workOrderAuditingRecord);


        // 添加新通知


        Notify notify = new Notify(NotifyTypeEnum.WORK_ORDER, form.getAuditingResult().getDesc(), workOrder.getYwPeopleId(), "0", "0", workOrder.getId());


        notifyService.save(notify);


        try {


            Notify notify = new Notify(NotifyTypeEnum.WORK_ORDER, form.getAuditingResult().getDesc(), workOrder.getYwPeopleId(), "0", "0", workOrder.getId());


            notifyService.save(notify);


        } catch (Exception e) {


            return Result.error("审核成功，通知运维人员失败");


        }


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


    }




@@ -153,7 +167,7 @@


        return Result.ok().data(


                new LambdaQueryChainWrapper<>(workOrderAuditingRecordMapper)


                        .eq(WorkOrderAuditingRecord::getWorkOrderId, id)


                        .orderByDesc(WorkOrderAuditingRecord::getCreateTime)


                        .orderByAsc(WorkOrderAuditingRecord::getCreateTime)


                        .list());


    }




@@ -258,17 +272,125 @@




    @Override


    public Result distributeFast(DistributeWorkOrderVO data) {


        List<WorkOrder> willDistributeList = new ArrayList<>(32);


        // 如果是自定义时间范围


        if (FastDistributeTypeEnum.CUSTOM == data.getFastWay()) {


        // 获取当前时间


        LocalDateTime now = LocalDateTime.now(ZoneId.systemDefault());


        switch (data.getFastWay()) {


            case LAST_HALF_HOUR:


                data.setStart(now.minusMinutes(30));


                data.setEnd(now);


                break;


            case LAST_HOUR:


                data.setStart(now.minusHours(1));


                data.setEnd(now);


                break;


            case LAST_TWO_HOUR:


               data.setStart(now.minusHours(2));


               data.setEnd(now);


               break;


            case LAST_DAY:


                data.setStart(now.minusDays(1));


                data.setEnd(now);


                break;


           }




        // 查询符合条件的工单


        List<Integer> ids = new LambdaQueryChainWrapper<>(baseMapper)


                .eq(WorkOrder::getStatus, WorkOrderStatusEnum.WAIT_DISTRIBUTE)


                .eq(Objects.nonNull(data.getUnitId()), WorkOrder::getUnitId, data.getUnitId())


                .eq(WorkOrder::getErrorType, data.getErrorType())


                .between(WorkOrder::getCreateTime, data.getStart(), data.getEnd())


                .orderByDesc(WorkOrder::getCreateTime)


                .last("limit " + data.getFastNumLimit())


                .list()


                .stream()


                .map(WorkOrder::getId)


                .toList();




        if (ids.isEmpty()) {


            return Result.error("没有符合条件的工单");


        }


        if (!getDistributeLock()) {


            return Result.error("工单下发中，请稍后重试");


        }


        try {


            new LambdaUpdateChainWrapper<>(baseMapper)


                    .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)


                    .in(WorkOrder::getId, ids)


                    .update();


            addDistributeRecord(ids, WorkOrderDistributeWayEnum.FAST_DISTRIBUTE);


            return Result.ok("成功下发" + ids.size() + "条工单");


        } catch (Exception e) {


            return Result.error("操作失败");


        } finally {


            distributeUnLock();


        }


    }




        new LambdaUpdateChainWrapper<>(baseMapper)


                .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)


                .update();


    @Override


    public Result selectedIdsDistribute(DistributeWorkOrderQuery query) {


        WorkOrderDistributeWayEnum distributeWayEnum = WorkOrderDistributeWayEnum.SELECTED_DISTRIBUTE;


        if (!getDistributeLock()) {


            return Result.error("此刻有人下发中，为避免冲突，请稍后重试");


        }


        try {


            if (query.getIds().isEmpty()) {


                query.setIds(new LambdaQueryChainWrapper<>(baseMapper)


                        .eq(WorkOrder::getStatus, WorkOrderStatusEnum.WAIT_DISTRIBUTE)


                        .eq(Objects.nonNull(query.getUnitId()), WorkOrder::getUnitId, query.getUnitId())


                        .select(WorkOrder::getId)


                        .list()


                        .stream()


                        .map(WorkOrder::getId)


                        .collect(Collectors.toList()));


                distributeWayEnum = WorkOrderDistributeWayEnum.ALL_DISTRIBUTE;


            }


            if (query.getIds().isEmpty()) {


                return Result.error("没有工单待下发");


            }


            new LambdaUpdateChainWrapper<>(baseMapper)


                    .set(WorkOrder::getStatus, WorkOrderStatusEnum.DISTRIBUTED)


                    .in(WorkOrder::getId, query.getIds())


                    .update();


            addDistributeRecord(query.getIds(), distributeWayEnum);


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


        } catch (Exception e) {


            return Result.error("操作失败");


        } finally {


            distributeUnLock();


        }


    }




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


    /**


     * 申请工单下发锁


     * @return 工单下发锁申请结果


     */


    public synchronized Boolean getDistributeLock() {


        if (Objects.isNull(redisCache.getCacheObject(DISTRIBUTE_LOCK_KEY))) {


            redisCache.setCacheObject(DISTRIBUTE_LOCK_KEY, "1");


            return true;


        } else {


            return false;


        }


    }




    /**


     * 工单下发锁释放


     */


    public synchronized void distributeUnLock() {


        redisCache.deleteObject(DISTRIBUTE_LOCK_KEY);


    }




    /**


     * 添加工单下发记录


     * @param ids 工单id


     */


    private void addDistributeRecord(List<Integer> ids, WorkOrderDistributeWayEnum distributeWay) {


        LoginUser loginUser = SecurityUtils.getLoginUser();


        workOrderDistributeRecordMapper.insertBatch(


                ids.stream()


                        .map(id -> new WorkOrderDistributeRecord(id, loginUser.getUserId(), distributeWay))


                        .toList()


        );


    }




    /**