任务工作档优化 代码优化 生成工作档优化

skyouc

4 天以前 930cf3fe63ddea4720ca6818df94c2161a04054f

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java

@@ -7,6 +7,7 @@
import com.vincent.rsf.server.api.entity.dto.InTaskMsgDto;
import com.vincent.rsf.server.api.service.WcsService;
import com.vincent.rsf.server.common.constant.Constants;
import com.vincent.rsf.server.manager.controller.params.LocToTaskParams;
import com.vincent.rsf.server.manager.enums.*;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
@@ -78,6 +79,10 @@
    private LocItemWorkingService locItemWorkingService;
    @Autowired
    private WcsService wcsService;
    @Autowired
    private OutStockService outStockService;
    @Autowired
    private OutStockItemService outStockItemService;

    @Override
    @Transactional(rollbackFor = Exception.class)
@@ -206,8 +211,8 @@
            if (!locService.update(new LambdaUpdateWrapper<Loc>()
                    .eq(Loc::getCode, task.getTargLoc())
                    .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_S.type)
                            .set(Loc::getUpdateBy, loginUserId)
                            .set(Loc::getUpdateTime, new Date())
                    .set(Loc::getUpdateBy, loginUserId)
                    .set(Loc::getUpdateTime, new Date())
                    .set(Loc::getBarcode, pakin.getBarcode()))) {
                throw new CoolException("库位预约失败！！");
            }
@@ -305,6 +310,7 @@
            task.setTaskCode(ruleCode)
                    .setTaskStatus(TaskStsType.GENERATE_IN.id)
                    .setTaskType(TaskType.TASK_TYPE_IN.type)
                    .setResource(TaskResouceType.TASK_RESOUCE_PAKIN_TYPE.val)
                    .setTargLoc(targetLoc)
                    .setBarcode(pakin.getBarcode())
                    .setOrgSite(deviceSite.getSite())
@@ -410,6 +416,139 @@
        }
    }

    /**
     * 任务置顶
     *
     * @param id
     * @param loginUserId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Task taskToTop(Long id, Long loginUserId) throws Exception {
        List<Integer> longs = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id);
        Task tasks = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getId, id).in(Task::getTaskStatus, longs));
        if (Objects.isNull(tasks)) {
            throw new CoolException("任务已处执行状态不可一键置顶！！");
        }
        //判断浅库位任务，修改任务优先级
        modiftyTaskSort(tasks, loginUserId);

        if (!taskService.updateById(tasks)) {
            throw new CoolException("置顶失败！！");
        }
        return null;
    }

    /**
     * 手动完成任务
     *
     * @param id
     * @param loginUserId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Task operateComplete(Long id, Long loginUserId) {
        List<Integer> longs = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id);
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>()
                .eq(Task::getId, id)
                .in(Task::getTaskStatus, longs));

        if (Objects.isNull(task)) {
            throw new CoolException("当前任务正在执行中，不可取消！！");
        }

        modiftyTaskSort(task, loginUserId);
        //
//        if (task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type)) {
//            task.setTaskStatus(TaskStsType.COMPLETE_OUT.id);
//        } else {
        task.setTaskStatus(task.getTaskType() < 100 ? TaskStsType.COMPLETE_IN.id : TaskStsType.COMPLETE_OUT.id);
//        }
        if (!this.updateById(task)) {
            throw new CoolException("完成任务失败");
        }
        return task;
    }

    /**
     * 修改任务优先级
     *
     * @param task
     * @param loginUserId
     */
    private Task modiftyTaskSort(Task task, Long loginUserId) {
        String curLoc;
        if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)) {
            curLoc = task.getTargLoc();
        } else {
            curLoc = task.getOrgLoc();
        }
        //深库位先出情况
        if (!LocUtils.isShallowLoc(curLoc)) {
            //深库位
            String shallowLoc = LocUtils.getShallowLoc(curLoc);
            if (StringUtils.isBlank(shallowLoc)) {
                throw new CoolException("数据异常，请联系管理员！");
            }
            Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, shallowLoc));
            if (Objects.isNull(loc)) {
                throw new CoolException("数据错误，库位不存在！！");
            }
            if (loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_S.type) || loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_R.type)) {
                Task serviceOne = taskService.getOne(new LambdaQueryWrapper<Task>()
                        .eq(Task::getOrgLoc, loc.getCode())
                        .or()
                        .eq(Task::getTargLoc, loc.getCode()));
                if (Objects.isNull(serviceOne)) {
                    task.setSort(Constants.TASK_SORT_MAX_VALUE);
                } else {
                    int i = serviceOne.getSort() - 1;
                    task.setSort(i);
                }
            }
//            else if (loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_F.type)) {
//                //如果为在库状态，生成移库任务
//                LocToTaskParams params = new LocToTaskParams();
//                params.setOrgLoc(curLoc);
//                //生成移深库位任务
//                Task moveTask = locItemService.genMoveTask(params, loginUserId);
//                moveTask.setTaskType(task.getSort() + 1);
//
//                return moveTask;
//            }
        }
        return task;
    }

    /**
     * 任务完成后，判断深库位是否为空，如果为空生成移库任务
     *
     * @param loginUserId
     * @param curLoc
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void moveToDeep(Long loginUserId, String curLoc) throws Exception {
        //浅库位，判断深对应深库位是否为空，如果为空生成一个移库任务，将托盘送入深库位
        String deepLoc = LocUtils.getDeepLoc(curLoc);
        if (StringUtils.isBlank(deepLoc)) {
            throw new CoolException("数据异常，请联系管理员！");
        }
        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, deepLoc));
        if (Objects.isNull(loc)) {
            throw new CoolException("数据错误，库位不存在！！");
        }
        //判断深库位是否为空
        if (loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_O.type)) {
            LocToTaskParams params = new LocToTaskParams();
            params.setOrgLoc(curLoc).setTarLoc(deepLoc);
            //生成移深库位任务
            locItemService.genMoveTask(params, loginUserId);
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void moveInStock(Task task, Long loginUserId) {
        if (Objects.isNull(task)) {
@@ -448,31 +587,30 @@
            if (!locItemService.remove(new LambdaQueryWrapper<LocItem>().eq(LocItem::getLocCode, task.getOrgLoc()))) {
                throw new CoolException("源库位明细删除失败！");
            }

        }

        /**修改库位状态为F.在库*/
        if (!locService.update(new LambdaUpdateWrapper<Loc>()
                        .set(Loc::getBarcode, task.getBarcode())
                        .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
                        .set(Loc::getUpdateBy, loginUserId)
                        .set(Loc::getUpdateTime, new Date())
                        .eq(Loc::getCode, task.getTargLoc()))) {
                .set(Loc::getBarcode, task.getBarcode())
                .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type)
                .set(Loc::getUpdateBy, loginUserId)
                .set(Loc::getUpdateTime, new Date())
                .eq(Loc::getCode, task.getTargLoc()))) {
            throw new CoolException("库位状态修改失败！！");
        }

        if (!locService.update(new LambdaUpdateWrapper<Loc>()
                        .set(Loc::getBarcode, null)
                        .set(Loc::getUpdateBy, loginUserId)
                        .set(Loc::getUpdateTime, new Date())
                        .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
                .set(Loc::getBarcode, null)
                .set(Loc::getUpdateBy, loginUserId)
                .set(Loc::getUpdateTime, new Date())
                .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
                .eq(Loc::getCode, task.getOrgLoc()))) {
            throw new CoolException("库位状态修改失败！！");
        }

        if (!this.update(new LambdaUpdateWrapper<Task>().eq(Task::getId, task.getId())
                        .set(Task::getUpdateBy, loginUserId)
                        .set(Task::getUpdateTime, new Date())
                .set(Task::getUpdateBy, loginUserId)
                .set(Task::getUpdateTime, new Date())
                .set(Task::getTaskStatus, TaskStsType.UPDATED_IN.id))) {
            throw new CoolException("任务状态修改失败！！");
        }
@@ -586,7 +724,9 @@
    @Transactional(rollbackFor = Exception.class)
    public R removeTask(Long[] ids, Long loginUserId) {
        List<Integer> longs = Arrays.asList(TaskStsType.GENERATE_IN.id, TaskStsType.GENERATE_OUT.id);
        List<Integer> list = Arrays.asList(TaskType.TASK_TYPE_IN.type, TaskType.TASK_TYPE_OUT.type, TaskType.TASK_TYPE_EMPITY_IN.type, TaskType.TASK_TYPE_EMPITY_OUT.type, TaskType.TASK_TYPE_MERGE_OUT.type);
        List<Integer> list = Arrays.asList(TaskType.TASK_TYPE_IN.type, TaskType.TASK_TYPE_OUT.type, TaskType.TASK_TYPE_PICK_AGAIN_OUT.type,
                TaskType.TASK_TYPE_CHECK_OUT.type, TaskType.TASK_TYPE_EMPITY_IN.type, TaskType.TASK_TYPE_LOC_MOVE.type,
                TaskType.TASK_TYPE_EMPITY_OUT.type, TaskType.TASK_TYPE_MERGE_OUT.type);
        List<Task> tasks = this.list(new LambdaQueryWrapper<Task>()
                .in(Task::getTaskType, list)
                .in(Task::getId, ids).in(Task::getTaskStatus, longs));
@@ -594,6 +734,34 @@
            throw new CoolException("任务已处执行状态不可取消！！");
        }
        for (Task task : tasks) {
            //取消移库任务
            if (task.getTaskType().equals(TaskType.TASK_TYPE_LOC_MOVE.type) && task.getTaskStatus().equals(TaskStsType.GENERATE_IN.id)) {
                if (!locService.update(new LambdaUpdateWrapper<Loc>()
                        .eq(Loc::getCode, task.getOrgLoc())
                        .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_F.type))) {
                    throw new CoolException("源库位状态修改失败！！");
                }
                if (!locService.update(new LambdaUpdateWrapper<Loc>().eq(Loc::getCode, task.getTargLoc()).set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type))) {
                    throw new CoolException("移库目标库位状态修改失败！！");
                }

                Task outTask = taskService.getById(task.getParentId());
                if (!Objects.isNull(outTask)) {
                    LocToTaskParams params = new LocToTaskParams();
                    params.setOrgLoc(task.getOrgLoc()).setSiteNo(task.getOrgSite());
                    //生成移深库位任务
                    Task moveTask = locItemService.genMoveTask(params, loginUserId);
                    moveTask.setSort(task.getSort() + 1).setParentId(outTask.getId());
                    if (!this.updateById(moveTask)) {
                        throw new CoolException("任务信息修改失败！！");
                    }
                    outTask.setParentId(moveTask.getId());
                    if (!this.updateById(outTask)) {
                        throw new CoolException("任务信息修改失败！！");
                    }
                }
            }

            if (!Objects.isNull(task.getWarehType()) && task.getWarehType().equals(WarehType.WAREHOUSE_TYPE_AGV.val)) {
                BasStation basStation = null;
                if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type) || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_IN.type)) {
@@ -605,8 +773,7 @@
                        || task.getTaskType().equals(TaskType.TASK_TYPE_PICK_AGAIN_OUT.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_MERGE_OUT.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_CHECK_OUT.type)
                        || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)
                ) {
                        || task.getTaskType().equals(TaskType.TASK_TYPE_EMPITY_OUT.type)) {
                    basStation = basStationService.getOne(new LambdaQueryWrapper<BasStation>()
                            .eq(BasStation::getStationName, task.getTargLoc())
                            .eq(BasStation::getUseStatus, LocStsType.LOC_STS_TYPE_R.type));
@@ -624,17 +791,47 @@
            if (!taskItems.isEmpty()) {
                for (TaskItem item : taskItems) {
                    if (item.getOrderType().equals(OrderType.ORDER_OUT.type)) {
                        Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getCode, task.getOrgLoc()));
                        if (Objects.isNull(loc)) {
                            throw new CoolException("数据错误：库位信息不存在！！");
                        }

                        loc.setUseStatus(LocStsType.LOC_STS_TYPE_F.type).setBarcode(task.getBarcode()).setUpdateBy(loginUserId).setUpdateTime(new Date());
                        if (!locService.updateById(loc)) {
                            throw new CoolException("库位信息修改失败！！");
                        }

                        //出库
                        if (item.getWkType().equals(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_OUT.type))) {
                            //库存出库
                            Loc loc = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getId, item.getSourceId()));
                            if (Objects.isNull(loc)) {
                                throw new CoolException("数据错误：库位信息不存在！！");
                        } else if (item.getWkType().equals(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_OTHER.type))) {
                            //其它出库
                        } else {
                            //出库单出库
                            AsnOrder asnOrder = outStockService.getById(item.getSourceId());
                            if (Objects.isNull(asnOrder)) {
                                throw new CoolException("数据错误：单据已不存在！！");
                            }
                            Double workQty = Math.round((asnOrder.getWorkQty() - item.getAnfme()) * 10000) / 10000.0;

                            asnOrder.setExceStatus(AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val)
                                    .setWorkQty(workQty.compareTo(0.00) > 0 ? workQty : 0.00)
                                    .setUpdateBy(loginUserId)
                                    .setUpdateTime(new Date());
                            if (!outStockService.updateById(asnOrder)) {
                                throw new CoolException("原单据状态修改失败！！");
                            }

                            loc.setUseStatus(LocStsType.LOC_STS_TYPE_F.type).setBarcode(task.getBarcode()).setUpdateBy(loginUserId).setUpdateTime(new Date());
                            if (!locService.updateById(loc)) {
                                throw new CoolException("库位信息修改失败！！");
                            AsnOrderItem orderItem = outStockItemService.getById(item.getSource());
                            if (Objects.isNull(orderItem)) {
                                throw new CoolException("数据错误：单据明细已不存在！！");
                            }

                            Double workItmQty = Math.round((orderItem.getWorkQty() - item.getAnfme()) * 10000) / 10000.0;
                            orderItem.setWorkQty(workItmQty);

                            if (!outStockItemService.updateById(orderItem)) {
                                throw new CoolException("原单据明细修改失败！！");
                            }
                        }
                    } else {
@@ -835,19 +1032,34 @@
        if (Objects.isNull(list) || list.isEmpty()) {
            Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
            maps.keySet().forEach(key -> {
                WaveItem waveItem = waveItemService.getById(key);
                if (Objects.isNull(waveItem)) {
                    throw new CoolException("波次明细不存在！！");
                }
                try {
                    saveOutStockItem(maps.get(key), waveItem, loginUserId);
                } catch (Exception e) {
                    throw new CoolException(e.getMessage());
                if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_WAVE_TYPE.val)) {
                    WaveItem waveItem = waveItemService.getById(key);
                    if (Objects.isNull(waveItem)) {
                        throw new CoolException("波次明细不存在！！");
                    }
                    try {
                        saveOutStockItem(maps.get(key), null, waveItem, loginUserId);
                    } catch (Exception e) {
                        throw new CoolException(e.getMessage());
                    }
                } else if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val)) {
                    AsnOrderItem orderItem = asnOrderItemService.getById(key);
                    if (Objects.isNull(orderItem)) {
                        throw new CoolException("单据明细不存在！！");
                    }

                    try {
                        saveOutStockItem(maps.get(key), orderItem, null, loginUserId);
                    } catch (Exception e) {
                        throw new CoolException(e.getMessage());
                    }
                } else {

                }
            });
        } else {
            try {
                saveOutStockItem(taskItems, null, loginUserId);
                saveOutStockItem(taskItems, null, null, loginUserId);
            } catch (Exception e) {
                throw new CoolException(e.getMessage());
            }
@@ -857,8 +1069,8 @@
        if (!locService.update(new LambdaUpdateWrapper<Loc>()
                .set(Loc::getUseStatus, LocStsType.LOC_STS_TYPE_O.type)
                .set(Loc::getBarcode, null)
                        .set(Loc::getUpdateBy, loginUserId)
                        .set(Loc::getUpdateTime, new Date())
                .set(Loc::getUpdateBy, loginUserId)
                .set(Loc::getUpdateTime, new Date())
                .eq(Loc::getId, loc.getId()))) {
            throw new CoolException("库位状态修改失败！！");
        }
@@ -894,7 +1106,7 @@
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void saveOutStockItem(List<TaskItem> taskItems, WaveItem waveItem, Long loginUserId) throws Exception {
    public void saveOutStockItem(List<TaskItem> taskItems, AsnOrderItem orderItem, WaveItem waveItem, Long loginUserId) throws Exception {
        Stock stock = new Stock();
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
        if (StringUtils.isBlank(ruleCode)) {
@@ -907,7 +1119,11 @@
                .setAnfme(sum);
        if (Objects.isNull(waveItem)) {
            stock.setWkType(Short.parseShort(OrderWorkType.ORDER_WORK_TYPE_STOCK_OUT.type))
                    .setMemo("出库单出库，无单据信息！！")
                    .setMemo("库存出库，无单据信息！！")
                    .setType(OrderType.ORDER_OUT.type);
        } else if (!Objects.isNull(orderItem) && StringUtils.isNotBlank(orderItem.getId() + "")) {
            AsnOrder asnOrder = asnOrderService.getById(orderItem.getAsnId());
            stock.setWkType(Short.parseShort(asnOrder.getWkType()))
                    .setType(OrderType.ORDER_OUT.type);
        } else {
            //TODO 生成波次时需要将波次号写入单据，通过物料，批次，动态字段等唯一值反查单据信息
@@ -1028,7 +1244,7 @@

        if (!waitPakinService.update(new LambdaUpdateWrapper<WaitPakin>()
                .set(WaitPakin::getIoStatus, PakinIOStatus.PAKIN_IO_STATUS_TASK_DONE.val)
                        .set(WaitPakin::getUpdateBy, loginUserId)
                .set(WaitPakin::getUpdateBy, loginUserId)
                .eq(WaitPakin::getId, pakinItem.getPakinId()))) {
            throw new CoolException("组拖状态修改失败！！");
        }