#

vincentlu

4 小时以前 6cbb420754e6e29fa134a6afca4514b8dfd62918

 zy-acs-manager/src/main/java/com/zy/acs/manager/manager/service/impl/TaskServiceImpl.java

@@ -6,9 +6,13 @@
import com.zy.acs.framework.common.Cools;
import com.zy.acs.framework.common.SnowflakeIdWorker;
import com.zy.acs.framework.exception.CoolException;
import com.zy.acs.manager.common.constant.Constants;
import com.zy.acs.manager.common.domain.BaseParam;
import com.zy.acs.manager.common.domain.PageParam;
import com.zy.acs.manager.common.domain.PageResult;
import com.zy.acs.manager.common.exception.BusinessException;
import com.zy.acs.manager.core.domain.Lane;
import com.zy.acs.manager.core.service.LaneService;
import com.zy.acs.manager.core.domain.LaneDto;
import com.zy.acs.manager.core.service.LaneBuilder;
import com.zy.acs.manager.manager.entity.*;
import com.zy.acs.manager.manager.enums.*;
import com.zy.acs.manager.manager.mapper.TaskMapper;
@@ -37,7 +41,20 @@
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private LaneService laneService;
    private LaneBuilder laneBuilder;
    @Autowired
    private StaReserveService staReserveService;
    @Autowired
    private SegmentService segmentService;
    @Autowired
    private ActionService actionService;
    @Autowired
    private TravelService travelService;

    @Override
    public PageResult<Task> pageRel(PageParam<Task, BaseParam> pageParam) {
        return new PageResult<>(this.baseMapper.selectPageRel(pageParam, pageParam.checkoutMap()), pageParam.getTotal());
    }

    @Override
    public synchronized String generateSeqNum() {
@@ -88,15 +105,37 @@
        if (null == task) {
            return Boolean.FALSE;
        }
        this.maintainLocSts(task, Boolean.TRUE);

        Date now = new Date();
        // stock
        this.maintainLocAndStaHandler(task, Boolean.TRUE);
        // task
        task.setTaskSts(TaskStsType.COMPLETE.val());
        task.setUpdateTime(new Date());
        task.setUpdateTime(now);
        task.setUpdateBy(userId);
        task.setMemo(Constants.HANDLE + " " + TaskStsType.COMPLETE);
        if (!this.updateById(task)) {
            throw new CoolException(BaseRes.ERROR);
        }
        // bus
        busService.checkoutComplete(task.getBusId());
        // segment
        List<Segment> segments = segmentService.list(new LambdaQueryWrapper<Segment>().eq(Segment::getTaskId, taskId));
        if (!Cools.isEmpty(segments)) {
            for (Segment segment : segments) {
                if (segment.getState().equals(SegmentStateType.FINISH.toString())) {
                    continue;
                }
                segment.setState(SegmentStateType.FINISH.toString());
                segment.setUpdateTime(now);
                segment.setUpdateBy(userId);
                segment.setMemo(Constants.HANDLE);
                if (!segmentService.updateById(segment)) {
                    throw new CoolException(BaseRes.ERROR);
                }
            }
            // travel
            travelService.checkFinish(segments.get(0).getTravelId());
        }
        return Boolean.TRUE;
    }

@@ -107,20 +146,41 @@
        if (null == task) {
            return Boolean.FALSE;
        }
        this.maintainLocSts(task, Boolean.FALSE);

        Date now = new Date();
        // stock
        this.maintainLocAndStaHandler(task, Boolean.FALSE);
        // task
        task.setTaskSts(TaskStsType.CANCEL.val());
        task.setUpdateTime(new Date());
        task.setUpdateTime(now);
        task.setUpdateBy(userId);
        task.setMemo(Constants.HANDLE + " " + TaskStsType.CANCEL);
        if (!this.updateById(task)) {
            throw new CoolException(BaseRes.ERROR);
        }
        busService.checkoutComplete(task.getBusId());
        // segment
        List<Segment> segments = segmentService.list(new LambdaQueryWrapper<Segment>().eq(Segment::getTaskId, taskId));
        if (!Cools.isEmpty(segments)) {
            for (Segment segment : segments) {
                if (segment.getState().equals(SegmentStateType.FINISH.toString())) {
                    continue;
                }
                segment.setState(SegmentStateType.FINISH.toString());
                segment.setUpdateTime(now);
                segment.setUpdateBy(userId);
                segment.setMemo(Constants.HANDLE);
                if (!segmentService.updateById(segment)) {
                    throw new CoolException(BaseRes.ERROR);
                }
            }
            // travel
            travelService.checkFinish(segments.get(0).getTravelId());
        }
        return Boolean.TRUE;
    }

    @Override
    public Lane checkoutOriginLane(Task task) {
    public LaneDto checkoutOriginLane(Task task) {
        Long codeId = null;
        TaskTypeType typeType = TaskTypeType.get(task.getTaskTypeEl());
        switch (Objects.requireNonNull(typeType)) {
@@ -139,11 +199,11 @@
        if (null == codeId) {
            return null;
        }
        return laneService.search(codeService.getCacheById(codeId).getData());
        return laneBuilder.search(codeService.getCacheById(codeId).getData());
    }

    @Override
    public Lane checkoutDestinationLane(Task task) {
    public LaneDto checkoutDestinationLane(Task task) {
        Long codeId = null;
        TaskTypeType typeType = TaskTypeType.get(task.getTaskTypeEl());
        switch (Objects.requireNonNull(typeType)) {
@@ -162,7 +222,7 @@
        if (null == codeId) {
            return null;
        }
        return laneService.search(codeService.getCacheById(codeId).getData());
        return laneBuilder.search(codeService.getCacheById(codeId).getData());
    }

    @Override
@@ -212,8 +272,85 @@
        return this.list(wrapper).stream().findFirst().orElse(null);
    }

    @Override
    public void maintainLocAndSta(Task task) {
        if (null == task) {
            return;
        }
        if (!task.getTaskSts().equals(TaskStsType.COMPLETE.val())) {
            return;
        }
        Date now = new Date();
        // loc status
        Loc oriLoc = null;
        Loc destLoc = null;
        Sta oriSta = null;
        Sta destSta = null;
        switch (Objects.requireNonNull(TaskTypeType.get(task.getTaskTypeEl()))) {
            case LOC_TO_LOC:
                oriLoc = locService.getById(task.getOriLoc());
                if (oriLoc.getLocSts().equals(LocStsType.PAKOUT.val())) {
                    oriLoc.setLocSts(LocStsType.IDLE.val());
                    oriLoc.setUpdateTime(now);
                    if (!locService.updateById(oriLoc)) {
                        log.error("Loc [{}] 库位修改状态失败", task.getOriLoc$());
                    }
                }

                destLoc = locService.getById(task.getDestLoc());
                if (destLoc.getLocSts().equals(LocStsType.PAKIN.val())) {
                    destLoc.setLocSts(LocStsType.STOCK.val());
                    destLoc.setUpdateTime(now);
                    if (!locService.updateById(destLoc)) {
                        log.error("Loc [{}] 库位修改状态失败", task.getDestLoc$());
                    }
                }
                break;
            case LOC_TO_STA:
                oriLoc = locService.getById(task.getOriLoc());
                if (oriLoc.getLocSts().equals(LocStsType.PAKOUT.val())) {
                    oriLoc.setLocSts(LocStsType.IDLE.val());
                    oriLoc.setUpdateTime(now);
                    if (!locService.updateById(oriLoc)) {
                        log.error("Loc [{}] 库位修改状态失败", task.getOriLoc$());
                    }
                }

                destSta = staService.getById(task.getDestSta());
                staReserveService.confirmStaReserve(destSta, task, 1, StaReserveType.IN);
                break;
            case STA_TO_LOC:
                oriSta = staService.getById(task.getOriSta());
                staReserveService.confirmStaReserve(oriSta, task, 1, StaReserveType.OUT);

                destLoc = locService.getById(task.getDestLoc());
                if (destLoc.getLocSts().equals(LocStsType.PAKIN.val())) {
                    destLoc.setLocSts(LocStsType.STOCK.val());
                    destLoc.setUpdateTime(now);
                    if (!locService.updateById(destLoc)) {
                        log.error("Loc [{}] 库位修改状态失败", task.getDestLoc$());
                    }
                }
                break;
            case STA_TO_STA:
                oriSta = staService.getById(task.getOriSta());
                staReserveService.confirmStaReserve(oriSta, task, 1, StaReserveType.OUT);

                destSta = staService.getById(task.getDestSta());
                staReserveService.confirmStaReserve(destSta, task, 1, StaReserveType.IN);
                break;
            case TO_CHARGE:
            case TO_STANDBY:
            case MOVE:
                break;
            default:
                break;
        }
    }


    @Transactional
    public void maintainLocSts(Task task, Boolean complete) {
    public void maintainLocAndStaHandler(Task task, Boolean complete) {
        Loc oriLoc = null; Loc destLoc = null;
        Sta oriSta = null; Sta destSta = null;
        Date now = new Date();
@@ -226,13 +363,13 @@
                oriLoc.setLocSts(complete?LocStsType.IDLE.val():LocStsType.STOCK.val());
                oriLoc.setUpdateTime(now);
                if (!locService.updateById(oriLoc)) {
                    throw new BusinessException("Loc [" + task.getOriLoc$() + "] 库位修改状态失败 ！！！");
                    throw new BusinessException("Loc [" + oriLoc.getLocNo() + "] 库位修改状态失败 ！！！");
                }

                destLoc.setLocSts(complete?LocStsType.STOCK.val():LocStsType.IDLE.val());
                destLoc.setUpdateTime(now);
                if (!locService.updateById(destLoc)) {
                    throw new BusinessException("Loc [" + task.getDestLoc$() + "] 库位修改状态失败 ！！！");
                    throw new BusinessException("Loc [" + destLoc.getLocNo() + "] 库位修改状态失败 ！！！");
                }
                break;
            case LOC_TO_STA:
@@ -240,18 +377,45 @@
                oriLoc.setLocSts(complete?LocStsType.IDLE.val():LocStsType.STOCK.val());
                oriLoc.setUpdateTime(now);
                if (!locService.updateById(oriLoc)) {
                    throw new BusinessException("Loc [" + task.getOriLoc$() + "] 库位修改状态失败 ！！！");
                    throw new BusinessException("Loc [" + oriLoc.getLocNo() + "] 库位修改状态失败 ！！！");
                }

                destSta = staService.getById(task.getDestSta());
                if (complete) {
                    staReserveService.confirmStaReserve(destSta, task, 1, StaReserveType.IN);
                } else {
                    staReserveService.cancelStaReserve(destSta, task, 1, StaReserveType.IN);
                }
                break;
            case STA_TO_LOC:
                oriSta = staService.getById(task.getOriSta());
                if (complete) {
                    staReserveService.confirmStaReserve(oriSta, task, 1, StaReserveType.OUT);
                } else {
                    staReserveService.cancelStaReserve(oriSta, task, 1, StaReserveType.OUT);
                }

                destLoc = locService.getById(task.getDestLoc());
                destLoc.setLocSts(complete?LocStsType.STOCK.val():LocStsType.IDLE.val());
                destLoc.setUpdateTime(now);
                if (!locService.updateById(destLoc)) {
                    throw new BusinessException("Loc [" + task.getDestLoc$() + "] 库位修改状态失败 ！！！");
                    throw new BusinessException("Loc [" + destLoc.getLocNo() + "] 库位修改状态失败 ！！！");
                }
                break;
            case STA_TO_STA:
                oriSta = staService.getById(task.getOriSta());
                if (complete) {
                    staReserveService.confirmStaReserve(oriSta, task, 1, StaReserveType.OUT);
                } else {
                    staReserveService.cancelStaReserve(oriSta, task, 1, StaReserveType.OUT);
                }

                destSta = staService.getById(task.getDestSta());
                if (complete) {
                    staReserveService.confirmStaReserve(destSta, task, 1, StaReserveType.IN);
                } else {
                    staReserveService.cancelStaReserve(destSta, task, 1, StaReserveType.IN);
                }
                break;
            case TO_CHARGE:
            case TO_STANDBY: