blame | 历史 | 补丁 | 提交 | 提交对比 | show whitespace
fuliqi
2024-08-01 82137fdbb4fc7d990b6f4d91f33ca80becad4545 
 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java


@@ -17,6 +17,7 @@


import com.ycl.platform.service.NotifyService;


import com.ycl.platform.service.WorkOrderAuditingRecordService;


import com.ycl.platform.service.WorkOrderService;


import com.ycl.platform.service.YwPointService;


import com.ycl.system.Result;


import com.ycl.system.model.LoginUser;


import com.ycl.system.page.PageUtil;


@@ -24,24 +25,21 @@


import com.ycl.utils.SecurityUtils;


import com.ycl.utils.redis.RedisCache;


import com.ycl.utils.uuid.IdUtils;


import constant.PointConfigConstants;


import enumeration.general.*;


import enumeration.general.NotifyTypeEnum;


import enumeration.general.UrgentLevelEnum;


import enumeration.general.WorkOrderDistributeWayEnum;


import enumeration.general.WorkOrderStatusEnum;


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 org.springframework.util.CollectionUtils;


import org.springframework.util.StringUtils;




import java.time.LocalDateTime;


import java.time.ZoneId;


import java.util.ArrayList;


import java.util.List;


import java.util.Objects;


import java.util.concurrent.TimeUnit;


import java.util.*;


import java.util.stream.Collectors;




/**


@@ -55,8 +53,7 @@


public class WorkOrderServiceImpl extends ServiceImpl<WorkOrderMapper, WorkOrder> implements WorkOrderService {




    private final WorkOrderMapper workOrderMapper;


    private final YwUnitMapper ywUnitMapper;


    private final YwPeopleMapper ywPeopleMapper;


    private final YwPointService ywPointService;


    private final WorkOrderAuditingRecordMapper workOrderAuditingRecordMapper;


    private final WorkOrderAuditingRecordService workOrderAuditingRecordService;


    private final WorkOrderYwConditionRecordMapper workOrderYwConditionRecordMapper;


@@ -126,6 +123,10 @@


                UrgentLevelEnum.WARNING,


                workOrder.getWorkOrderNo());


        notifyService.save(notify);


        // 同步点位状态


        if (form.getAuditingResult() == WorkOrderStatusEnum.AUDITING_SUCCESS) {


            ywPointService.updateRecovery(Collections.singletonList(workOrder.getPointId()), 0);


        }


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


    }




@@ -269,53 +270,49 @@


    }




    @Override


    @Transactional


    public Result distributeFast(DistributeWorkOrderVO data) {


        // 获取当前时间


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


        data.setEnd(now);


        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)


        List<WorkOrder> list = new LambdaQueryChainWrapper<>(baseMapper)


                .select(WorkOrder::getId, WorkOrder::getPointId)


                .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();


                .list();


        List<Integer> ids = list.stream().map(WorkOrder::getId).toList();


        List<Integer> pointIds = list.stream().map(WorkOrder::getPointId).toList();




        if (ids.isEmpty()) {


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


        }


        if (!getDistributeLock()) {


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


        }


        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);


            // 同步点位状态


            ywPointService.updateRecovery(pointIds, 1);


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


        } catch (Exception e) {


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


@@ -325,11 +322,10 @@


    }




    @Override


    @Transactional


    public Result selectedIdsDistribute(DistributeWorkOrderQuery query) {


        WorkOrderDistributeWayEnum distributeWayEnum = WorkOrderDistributeWayEnum.SELECTED_DISTRIBUTE;


        if (!getDistributeLock()) {


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


        }


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


        try {


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


                query.setIds(new LambdaQueryChainWrapper<>(baseMapper)


@@ -342,14 +338,15 @@


                        .collect(Collectors.toList()));


                distributeWayEnum = WorkOrderDistributeWayEnum.ALL_DISTRIBUTE;


            }


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


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


            }


            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);


            // 同步点位状态


            List<Integer> pointIds = new LambdaQueryChainWrapper<>(baseMapper).select(WorkOrder::getPointId).in(WorkOrder::getId, query.getIds()).list().stream().map(WorkOrder::getPointId).toList();


            ywPointService.updateRecovery(pointIds, 1);


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


        } catch (Exception e) {


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