出庫訂單完成上報功能優化

zc

22 小时以前 5213d5c3bf7c4b60fbb308fdadfb84f6d999c38b

出庫訂單完成上報功能優化

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReportMsgServiceImpl.java

@@ -291,14 +291,15 @@
            if (!Objects.isNull(user)) {
                nickName = user.getNickname();
            }
            //获取入库库位信息
                 //获取库存库位信息
            if (order.getType().equals(OrderType.ORDER_IN.type)) {
                //获取入库库位信息
                //筛选当前唯一字段所有出入库信息
                List<StockItem> stockItems = stockItemService.list(new LambdaQueryWrapper<StockItem>()
                        .eq(StockItem::getFieldsIndex, orderItem.getFieldsIndex()));
                //获取库存中订单库位
                Set<Long> longSet = stockItems.stream().map(StockItem::getStockId).collect(Collectors.toSet());
                //获取库存库位信息

                Stock stocks = stockService.getOne(new LambdaQueryWrapper<Stock>()
                        .in(Stock::getId, longSet)
                        .eq(Stock::getType, OrderType.ORDER_IN.type)
@@ -306,82 +307,173 @@
                if (!Objects.isNull(stocks)) {
                    param.setZone(stocks.getLocCode());
                }
            }
            //获取索引内容
            Map<String, String> fields = FieldsUtils.getFields(orderItem.getFieldsIndex());
                //获取索引内容
                Map<String, String> fields = FieldsUtils.getFields(orderItem.getFieldsIndex());
                //设置通用参数
                param.setWMSNO(order.getCode())
                        .setPONO(order.getPoCode())
                        .setOrderNO(order.getPoCode())
                        .setOrderDate(order.getCreateTime())
                        .setItemCode(orderItem.getMatnrCode())
                        .setEditUser(nickName)
                        .setEditDate(order.getUpdateTime())
                        .setGoodsNO(fields.get("crushNo"))
                        .setMemoDtl(order.getMemo());

            //设置通用参数
            param.setWMSNO(order.getCode())
                    .setPONO(order.getPoCode())
                    .setOrderNO(order.getPoCode())
                    .setOrderDate(order.getCreateTime())
                    .setItemCode(orderItem.getMatnrCode())
                    .setEditUser(nickName)
                    .setEditDate(order.getUpdateTime())
                    .setGoodsNO(fields.get("crushNo"))
                    .setMemoDtl(order.getMemo());
                if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_DONE_IN.type)) {
                    //采购入库单
                    params.setOrderType("PO_Instock").setAction("Update");
                    //获取指定查询字段CrushNo 票号
                    param.setInQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE_RETURN.type)) {
                    //采购退货
                    params.setOrderType("PR_Outstock").setAction("Update");
                    param.setOutQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_TERANSFER_IN.type)) {
                    //调拔入库单
                    params.setOrderType("Mv_Instock").setAction("Update");

            if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_DONE_IN.type)) {
                //采购入库单
                params.setOrderType("PO_Instock").setAction("Update");
                //获取指定查询字段CrushNo 票号
                param.setInQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE_RETURN.type)) {
                //采购退货
                params.setOrderType("PR_Outstock").setAction("Update");
                param.setOutQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_TERANSFER_IN.type)) {
                //调拔入库单
                params.setOrderType("Mv_Instock").setAction("Update");

            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD.type)) {
                //生产入库单
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD.type)) {
                    //生产入库单
//                params.setOrderType("WO_Outstock").setAction("Update");
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE.type)) {
                //生产退料
                params.setOrderType("WR_Instock").setAction("Update");
                param.setInQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_RETURN_ORDER.type)) {
                //生产领料
                params.setOrderType("WO_Outstock").setAction("Update");
                param.setOutQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE.type)) {
                    //生产退料
                    params.setOrderType("WR_Instock").setAction("Update");
                    param.setInQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_RETURN_ORDER.type)) {
                    //生产领料
                    params.setOrderType("WO_Outstock").setAction("Update");
                    param.setOutQty(orderItem.getQty());

            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD_ADDITION.type)) {
                //生产补料
                params.setOrderType("WR_Instock_BL").setAction("Update");
                param.setOutQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_FIX_OUT.type)) {
                params.setOrderType("WO_Outstock_WR").setAction("Update");
                param.setOutQty(orderItem.getQty());
            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_IN.type)) {
                //其它入库单/手动入库单
                params.setOrderType("In_Instock").setAction("Update");
                param.setInQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD_ADDITION.type)) {
                    //生产补料
                    params.setOrderType("WR_Instock_BL").setAction("Update");
                    param.setOutQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_FIX_OUT.type)) {
                    params.setOrderType("WO_Outstock_WR").setAction("Update");
                    param.setOutQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_IN.type)) {
                    //其它入库单/手动入库单
                    params.setOrderType("In_Instock").setAction("Update");
                    param.setInQty(orderItem.getQty());

            } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER.type)) {
                //其它出库单/手动出库单
                params.setOrderType("Io_Outstock").setAction("Update");
                param.setOutQty(orderItem.getQty());
                } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER.type)) {
                    //其它出库单/手动出库单
                    params.setOrderType("Io_Outstock").setAction("Update");
                    param.setOutQty(orderItem.getQty());
                }
                reportData.add(param);


                params.setData(reportData);
                try {
                    R reported = uploadReportOrders(params);
                    if (Integer.valueOf(reported.get("code").toString()) == 200) {
                        order.setNtyStatus(OrderReportStatus.ORDER_REPORT_STATUS_ALL.val);
                        asnOrderService.updateById(order);
                    }
                } catch (Exception e) {
                    log.error("<UNK>", e);
                }
                try {
                    //休眠3秒
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            } else if (order.getType().equals(OrderType.ORDER_OUT.type)){
                List<Stock> stocks = stockService.list(new LambdaQueryWrapper<Stock>().eq(Stock::getSourceCode, order.getCode()));
                if (stocks.isEmpty()) {
                    throw new CoolException("出庫歷史不存在！！");
                }
                String finalNickName = nickName;
                stocks.forEach(stock -> {
                    //筛选当前唯一字段所有出入库信息
                    List<StockItem> stockItems = stockItemService.list(new LambdaQueryWrapper<StockItem>()
                            .eq(StockItem::getStockId, stock.getId()));
                    if (stockItems.isEmpty()) {
                        throw new CoolException("出庫單明細不存在！！");
                    }
                    //获取库存中订单库位
//                Set<Long> longSet = stockItems.stream().map(StockItem::getStockId).collect(Collectors.toSet());
                    stockItems.forEach(items -> {
                        List<ReportDataParam> dataParams = new ArrayList<>();
                        //获取索引内容
                        Map<String, String> fields = FieldsUtils.getFields(items.getFieldsIndex());
                        //设置通用参数
                        param.setWMSNO(order.getCode())
                                .setPONO(order.getPoCode())
                                .setOrderNO(order.getPoCode())
                                .setOrderDate(order.getCreateTime())
                                .setItemCode(items.getMatnrCode())
                                .setEditUser(finalNickName)
                                .setEditDate(order.getUpdateTime())
                                .setGoodsNO(fields.get("crushNo"))
                                .setMemoDtl(order.getMemo());

                        if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_DONE_IN.type)) {
                            //采购入库单
                            params.setOrderType("PO_Instock").setAction("Update");
                            //获取指定查询字段CrushNo 票号
                            param.setInQty(orderItem.getQty());
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE_RETURN.type)) {
                            //采购退货
                            params.setOrderType("PR_Outstock").setAction("Update");
                            param.setOutQty(orderItem.getQty());
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_TERANSFER_IN.type)) {
                            //调拔入库单
                            params.setOrderType("Mv_Instock").setAction("Update");
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD.type)) {
                            //生产入库单
//                      params.setOrderType("WO_Outstock").setAction("Update");
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PURCHASE.type)) {
                            //生产退料
                            params.setOrderType("WR_Instock").setAction("Update");
                            param.setInQty(orderItem.getQty());
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_RETURN_ORDER.type)) {
                            //生产领料
                            params.setOrderType("WO_Outstock").setAction("Update");
                            param.setOutQty(orderItem.getQty());
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_PROD_ADDITION.type)) {
                            //生产补料
                            params.setOrderType("WR_Instock_BL").setAction("Update");
                            param.setOutQty(orderItem.getQty());
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_FIX_OUT.type)) {
                            params.setOrderType("WO_Outstock_WR").setAction("Update");
                            param.setOutQty(orderItem.getQty());
                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER_IN.type)) {
                            //其它入库单/手动入库单
                            params.setOrderType("In_Instock").setAction("Update");
                            param.setInQty(orderItem.getQty());

                        } else if (order.getWkType().equals(OrderWorkType.ORDER_WORK_TYPE_OTHER.type)) {
                            //其它出库单/手动出库单
                            params.setOrderType("Io_Outstock").setAction("Update");
                            param.setOutQty(orderItem.getQty());
                        }
                        dataParams.add(param);

                        params.setData(dataParams);
                        try {
                            R reported = uploadReportOrders(params);
                            if (Integer.valueOf(reported.get("code").toString()) == 200) {
                                order.setReportOnce(5);
                                asnOrderService.updateById(order);
                            }
                        } catch (Exception e) {
                            log.error("<UNK>", e);
                        }
                        try {
                            //休眠3秒
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    });
                });
            }
            reportData.add(param);
        });
        params.setData(reportData);
        try {
            R reported = uploadReportOrders(params);
            if (Integer.valueOf(reported.get("code").toString()) == 200) {
                order.setNtyStatus(OrderReportStatus.ORDER_REPORT_STATUS_ALL.val);
                asnOrderService.updateById(order);
            }
        } catch (Exception e) {
            log.error("<UNK>", e);
        }

        try {
            //休眠3秒
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    /**

 rsf-server/src/main/java/com/vincent/rsf/server/manager/enums/LocStsType.java

@@ -65,15 +65,15 @@
     */

    public static String getRcsLocSts(String val) {

        if (val.equals(LocStsType.LOC_STS_TYPE_O.type)) {

            return RcsLocStsType.LOC_STS_TYPE_D.type;

            return RcsLocStsType.LOC_STS_TYPE_D.desc;

        } else if (val.equals(LocStsType.LOC_STS_TYPE_F.type)) {

            return RcsLocStsType.LOC_STS_TYPE_F.type;

            return RcsLocStsType.LOC_STS_TYPE_F.desc;

        } else if (val.equals(LocStsType.LOC_STS_TYPE_S.type)) {

            return RcsLocStsType.LOC_STS_TYPE_S.type;

            return RcsLocStsType.LOC_STS_TYPE_S.desc;

        } else if (val.equals(LocStsType.LOC_STS_TYPE_R.type)) {

            return RcsLocStsType.LOC_STS_TYPE_R.type;

            return RcsLocStsType.LOC_STS_TYPE_R.desc;

        } else if (val.equals(LocStsType.LOC_STS_TYPE_X.type)) {

            return RcsLocStsType.LOC_STS_TYPE_X.type;

            return RcsLocStsType.LOC_STS_TYPE_X.desc;

        }

        return null;

    }


 rsf-server/src/main/java/com/vincent/rsf/server/manager/schedules/AsnOrderLogSchedule.java

@@ -64,7 +64,7 @@
     * @description 删除已完成订单加入Log表
     * @time 2025/3/19 19:09
     */
    @Scheduled(cron = "0/35 * * * * ?  ")
    @Scheduled(cron = "0 0 2 1 * ?")
    @Transactional(rollbackFor = Exception.class)
    public void InStockToLog() {
        List<WkOrder> wkOrders = asnOrderService.list(new LambdaQueryWrapper<WkOrder>()
@@ -89,7 +89,8 @@
     * @description 出库单完成后，状态修改
     * @time 2025/6/16 08:35
     */
    @Scheduled(cron = "0/30 * * * * ?  ")
    @Scheduled(cron = "0/15 * * * * ?  ")
//    @Scheduled(cron = "0 0 2 1 * ?")
    @Transactional(rollbackFor = Exception.class)
    public void outStockComplete() {
        List<WkOrder> wkOrders = asnOrderService.list(new LambdaQueryWrapper<WkOrder>()
@@ -141,7 +142,7 @@
                    log.error(e.getMessage());
                }
            }
            if (order.getNtyStatus().equals(OrderReportStatus.ORDER_REPORT_STATUS_ALL.val)) {
            if (order.getType().equals(OrderType.ORDER_OUT.type) &&  order.getReportOnce() >= 4) {
                AsnOrderLog one = asnOrderLogService.getOne(new LambdaQueryWrapper<AsnOrderLog>().eq(AsnOrderLog::getCode, order.getCode()), false);
                if (Objects.isNull(one)) {
                    AsnOrderLog orderLog = new AsnOrderLog();

 rsf-server/src/main/java/com/vincent/rsf/server/manager/schedules/TaskSchedules.java

@@ -558,27 +558,25 @@
            List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
            //入库单据明细上报

            for (TaskItem taskItem : taskItems) {
                if (Objects.isNull(taskItem.getOrderId())) {
                    continue;
            if (task.getTaskType().equals(TaskType.TASK_TYPE_IN.type)) {
                for (TaskItem taskItem : taskItems) {
                    if (Objects.isNull(taskItem.getOrderId())) {
                        continue;
                    }
                    WkOrder order = asnOrderService.getById(taskItem.getOrderId());
                    if (Objects.isNull(order)) {
                        continue;
                    }
                    //入库单任务明细上报
                    WkOrderItem wkOrderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                            .eq(WkOrderItem::getOrderId, order.getId())
                            .eq(WkOrderItem::getFieldsIndex, taskItem.getFieldsIndex()));
                    if (Objects.isNull(wkOrderItem)) {
                        throw new CoolException("数据错误，单据明细不存在或已完成！！");
                    }
                    /**入库单明细上报*/
                    reportMsgService.reportOrderItem(wkOrderItem);
                }
                WkOrder order = asnOrderService.getById(taskItem.getOrderId());
                if (Objects.isNull(order)) {
                    continue;
                }
                //入库单任务明细上报
                WkOrderItem wkOrderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getOrderId, order.getId())
                        .eq(WkOrderItem::getFieldsIndex, taskItem.getFieldsIndex()));
                if (Objects.isNull(wkOrderItem)) {
                    throw new CoolException("数据错误，单据明细不存在或已完成！！");
                }
                /**入库单明细上报*/
                reportMsgService.reportOrderItem(wkOrderItem);
            }

            if (task.getTaskType() <= TaskType.TASK_TYPE_CHECK_IN.type) {

            } else if (task.getTaskType() >= TaskType.TASK_TYPE_OUT.type && task.getTaskType() <= TaskType.TASK_TYPE_EMPITY_OUT.type) {
                //出库单上报RCS修改库位状态
                try {
@@ -636,11 +634,9 @@
        }

        LocSiteParams locSiteParams = new LocSiteParams();
        locSiteParams
                .setStatus(LocStsType.getRcsLocSts(LocStsType.LOC_STS_TYPE_O.type))
        locSiteParams.setStatus(LocStsType.getRcsLocSts(LocStsType.LOC_STS_TYPE_O.type))
                .setType("site")
                .setCode(station.getStationName());

        /**WMS基础配置链接*/
        String rcsUrl = rcsApi.getHost() + ":" + rcsApi.getPort() + RcsConstant.REPORT_SITE_STATUS;
        log.info("上报已完成订单：{}， 请求参数： {}", rcsUrl, JSONObject.toJSONString(locSiteParams));
@@ -651,6 +647,7 @@
        HttpEntity httpEntity = new HttpEntity(locSiteParams, headers);
        ResponseEntity<String> exchange = restTemplate.exchange(rcsUrl, HttpMethod.POST, httpEntity, String.class);
        log.info("上报已完成订单，返回结果： {}", exchange);

        if (Objects.isNull(exchange.getBody())) {
            throw new CoolException("修改失败！！");
        } else {
@@ -663,7 +660,6 @@
                throw new CoolException(e.getMessage());
            }
        }

    }

}

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

@@ -683,9 +683,9 @@
        if (Objects.isNull(loc)) {
            throw new CoolException("库存不存在！！");
        }
        if (!loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_S.type)) {
            throw new CoolException("当前库位状态不处于S.入库预约，不可执行入库操作！");
        }
//        if (!loc.getUseStatus().equals(LocStsType.LOC_STS_TYPE_S.type)) {
//            throw new CoolException("当前库位状态不处于S.入库预约，不可执行入库操作！");
//        }

        loc.setUseStatus(LocStsType.LOC_STS_TYPE_F.type)
                .setBarcode(task.getBarcode())