blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
xiangpei
2024-04-23 6fe2d3e9a1348078cc7ffad1c55968c5ad97e207 
 ycl-server/src/main/java/com/ycl/platform/service/impl/WorkOrderServiceImpl.java


@@ -1,44 +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.time.LocalDateTime;


import java.time.ZoneId;


import java.time.temporal.ChronoUnit;


import java.util.Arrays;


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 lombok.RequiredArgsConstructor;


import org.apache.commons.lang3.ArrayUtils;


import org.springframework.stereotype.Service;


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;




/**


 * 工单 服务实现类


@@ -56,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;




    /**


     * 添加


@@ -289,6 +293,7 @@


                break;


           }




        // 查询符合条件的工单


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


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


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


@@ -303,24 +308,89 @@




        if (ids.isEmpty()) {


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


        } else {


        }


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


        }


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


    }




    @Override


    public Result selectedIdsDistribute(List<Integer> ids, Integer unitId) {


        new LambdaUpdateChainWrapper<>(baseMapper)


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


                .in(ArrayUtils.isNotEmpty(ids.toArray()), WorkOrder::getId, ids)


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


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


                .update();


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


    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("成功下发" + query.getIds().size() + "条工单");


        } catch (Exception e) {


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


        } finally {


            distributeUnLock();


        }


    }




    /**


     * 申请工单下发锁


     * @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()


        );


    }




    /**