lsh#订单完结

1

6 天以前 db06b944e7886832d20b8e3ae62b2cb70bcba30f

 rsf-open-api/src/main/java/com/vincent/rsf/openApi/service/phyz/impl/ErpReportServiceImpl.java

@@ -14,7 +14,6 @@
import com.vincent.rsf.openApi.entity.app.OpenApiOrder;
import com.vincent.rsf.openApi.entity.app.OpenApiOrderItem;
import com.vincent.rsf.openApi.entity.app.OpenApiOrderItemMap;
import com.vincent.rsf.openApi.entity.app.OpenApiOrderReportEvent;
import com.vincent.rsf.openApi.entity.constant.WmsConstant;
import com.vincent.rsf.openApi.entity.dto.CommonResponse;
import com.vincent.rsf.openApi.entity.phyz.*;
@@ -23,7 +22,6 @@
import com.vincent.rsf.openApi.mapper.OpenApiOrderItemMapMapper;
import com.vincent.rsf.openApi.mapper.OpenApiOrderItemMapper;
import com.vincent.rsf.openApi.mapper.OpenApiOrderMapper;
import com.vincent.rsf.openApi.mapper.OpenApiOrderReportEventMapper;
import com.vincent.rsf.openApi.service.WmsErpService;
import com.vincent.rsf.openApi.service.phyz.ErpReportService;
import com.vincent.rsf.openApi.utils.ParamsMapUtils;
@@ -83,8 +81,6 @@
    private OpenApiOrderItemMapper openApiOrderItemMapper;
    @Resource
    private OpenApiOrderItemMapMapper openApiOrderItemMapMapper;
    @Resource
    private OpenApiOrderReportEventMapper openApiOrderReportEventMapper;

    private static final BigDecimal ZERO = BigDecimal.ZERO.setScale(2, RoundingMode.HALF_UP);

@@ -442,120 +438,185 @@
        }
        JSONObject root = JSONObject.parseObject(JSON.toJSONString(params));

        String eventId = pickString(root, "eventId", "EventId");
        String taskNo = pickString(root, "taskNo", "TaskNo");
        String reportNo = pickString(root, "reportNo", "ReportNo");
        if (StringUtils.isBlank(eventId) && StringUtils.isBlank(taskNo) && StringUtils.isBlank(reportNo)) {
            throw new CoolException("幂等键不能为空（eventId/taskNo/reportNo）");
        String orderNo = pickString(root, "orderNo", "OrderNo", "WMSNO", "wmsno");
        if (StringUtils.isBlank(orderNo)) {
            return CommonResponse.error("orderNo不能为空");
        }

        if (existsReportEvent(eventId, taskNo, reportNo)) {
            return CommonResponse.ok("重复回传已忽略");
        // 解析明细：优先取 orderItems（Order格式），兼容 Data/data（ReportParams格式）
        JSONArray dataArray = pickArray(root, "orderItems", "orderItems");
        if (Objects.isNull(dataArray) || dataArray.isEmpty()) {
            dataArray = pickArray(root, "Data", "data");
        }
        OpenApiOrderReportEvent reportEvent = saveReportEvent(eventId, taskNo, reportNo, pickString(root, "orderNo", "WMSNO"), root.toJSONString());

        JSONArray dataArray = pickArray(root, "Data", "data");
        if (Objects.isNull(dataArray) || dataArray.isEmpty()) {
            return CommonResponse.error("回传明细为空");
        }

        // 对回传数据做反映射（WMS字段名 → ERP字段名）
        // 对回传数据做反映射（WMS字段名 → ERP字段名），兼容旧格式
        JSONObject mappedRoot = ParamsMapUtils.reverseApiMaps("erp", "orderId", root);
        JSONArray mappedDataArray = pickArray(mappedRoot, "Data", "data");
        JSONArray mappedDataArray = pickArray(mappedRoot, "orderItems", "orderItems");
        if (Objects.isNull(mappedDataArray) || mappedDataArray.isEmpty()) {
            mappedDataArray = pickArray(mappedRoot, "Data", "data");
        }
        if (Objects.isNull(mappedDataArray) || mappedDataArray.isEmpty()) {
            mappedDataArray = dataArray;
        }

        int allocateCount = 0;
        int erpReportCount = 0;
        List<String> errors = new ArrayList<>();
        Set<String> affectedOrderNos = new HashSet<>();
        Map<String, OpenApiOrder> orderCache = new HashMap<>();

        for (int i = 0; i < mappedDataArray.size(); i++) {
            JSONObject row = mappedDataArray.getJSONObject(i);
            String orderNo = pickString(row, "WMSNO", "wmsNo", "orderNo", "OrderNo");
            String matnrCode = pickString(row, "ItemCode", "itemCode", "matNr", "MatNr");
            String batch = pickString(row, "Batch", "batch", "GoodsNO", "goodsNo");
            BigDecimal doneQty = pickDecimal(row, "qty", "doneQty", "InQty", "OutQty");
            if (StringUtils.isBlank(orderNo) || StringUtils.isBlank(matnrCode) || doneQty.compareTo(ZERO) <= 0) {
                errors.add("第" + (i + 1) + "行缺少必要字段（WMSNO/ItemCode/数量）");
            String matnrCode = pickString(row, "matNr", "MatNr", "ItemCode", "itemCode");
            String batch = pickString(row, "batch", "Batch", "GoodsNO", "goodsNo");
            String lineId = pickString(row, "lineId", "LineId", "sourceLineId");
            BigDecimal doneQty = pickDecimal(row, "doneQty", "anfme", "qty", "InQty", "inQty", "OutQty", "outQty", "pdqty", "PDQty");
            if (StringUtils.isBlank(matnrCode) || doneQty.compareTo(ZERO) <= 0) {
                errors.add("第" + (i + 1) + "行缺少必要字段（matNr/数量）");
                continue;
            }
            doneQty = doneQty.setScale(2, RoundingMode.HALF_UP);

            try {
                int singleAllocated = allocateMergedDoneQty(orderNo, matnrCode, batch, doneQty);
                int singleAllocated = allocateMergedDoneQty(orderNo, matnrCode, batch, lineId, doneQty, orderCache);
                allocateCount += singleAllocated;
                erpReportCount += reportReadyLinesToErp(orderNo);
                refreshOrderFinishStatus(orderNo);
                affectedOrderNos.add(orderNo);
            } catch (Exception e) {
                log.error("处理回传失败，orderNo={}, matnr={}, batch={}", orderNo, matnrCode, batch, e);
                log.error("处理回传失败，orderNo={}, matnr={}, batch={}, lineId={}", orderNo, matnrCode, batch, lineId, e);
                errors.add("第" + (i + 1) + "行处理失败：" + e.getMessage());
            }
        }

        // 反映射后组装ReportParams，参照旧链路上报ERP
        try {
            ReportParams erpReportParams = buildReportParamsFromMappedData(mappedRoot, mappedDataArray);
            CommonResponse erpResp = wmsErpService.reportOrders(erpReportParams);
            if (Objects.nonNull(erpResp) && Objects.equals(erpResp.getCode(), 200)) {
                log.info("反映射上报ERP成功，orderNo={}", pickString(root, "orderNo", "WMSNO"));
            } else {
                String msg = Objects.isNull(erpResp) ? "ERP响应为空" : erpResp.getMsg();
                errors.add("上报ERP失败：" + msg);
            }
        } catch (Exception e) {
            log.error("反映射上报ERP异常", e);
            errors.add("上报ERP异常：" + e.getMessage());
        // 循环结束后，每个受影响订单只刷新一次状态
        for (String no : affectedOrderNos) {
            refreshOrderFinishStatus(no);
        }

        if (!errors.isEmpty()) {
            reportEvent.setStatus(2);
            openApiOrderReportEventMapper.updateById(reportEvent);
            return CommonResponse.error("处理完成，但存在异常：" + String.join(" | ", errors));
        }
        reportEvent.setStatus(1);
        openApiOrderReportEventMapper.updateById(reportEvent);

        Map<String, Object> result = new HashMap<>();
        result.put("allocatedCount", allocateCount);
        result.put("erpReportCount", erpReportCount);
        return CommonResponse.ok(result);
    }

    /**
     * 根据反映射后的数据组装ReportParams，参照旧链路wmsErpService.reportOrders格式上报ERP
     * 查询已完成但未上报ERP的订单，组装ReportParams上报ERP
     * 由asrs-schedule定时任务触发
     */
    private ReportParams buildReportParamsFromMappedData(JSONObject root, JSONArray dataArray) {
        String orderType = pickString(root, "OrderType", "orderType", "type", "wkType");
    @Override
    public CommonResponse reportOrdersToErp() {
        List<OpenApiOrder> pendingOrders = openApiOrderMapper.selectList(new LambdaQueryWrapper<OpenApiOrder>()
                .eq(OpenApiOrder::getExceStatus, 2)
                .eq(OpenApiOrder::getNtyStatus, 0)
                .last("limit 50"));
        if (pendingOrders.isEmpty()) {
            return CommonResponse.ok("无待上报ERP的订单");
        }

        List<String> errors = new ArrayList<>();
        int successCount = 0;
        for (OpenApiOrder order : pendingOrders) {
            try {
                List<OpenApiOrderItem> items = openApiOrderItemMapper.selectList(new LambdaQueryWrapper<OpenApiOrderItem>()
                        .eq(OpenApiOrderItem::getOrderId, order.getId()));
                if (items.isEmpty()) {
                    log.warn("订单无明细，跳过上报ERP，orderNo={}", order.getCode());
                    continue;
                }

                ReportParams erpParams = buildReportParams(order, items);
                CommonResponse erpResp = wmsErpService.reportOrders(erpParams);
                if (Objects.nonNull(erpResp) && Objects.equals(erpResp.getCode(), 200)) {
                    order.setNtyStatus(1);
                    openApiOrderMapper.updateById(order);
                    successCount++;
                    log.info("上报ERP成功，orderNo={}", order.getCode());
                } else {
                    String msg = Objects.isNull(erpResp) ? "ERP响应为空" : erpResp.getMsg();
                    log.warn("上报ERP失败，orderNo={}，msg={}", order.getCode(), msg);
                    errors.add(order.getCode() + ":" + msg);
                }
            } catch (Exception e) {
                log.error("上报ERP异常，orderNo={}", order.getCode(), e);
                errors.add(order.getCode() + ":" + e.getMessage());
            }
        }

        if (!errors.isEmpty()) {
            Map<String, Object> result = new HashMap<>();
            result.put("successCount", successCount);
            result.put("totalCount", pendingOrders.size());
            return CommonResponse.error("部分订单上报ERP失败：" + String.join(" | ", errors));
        }

        Map<String, Object> result = new HashMap<>();
        result.put("successCount", successCount);
        result.put("totalCount", pendingOrders.size());
        return CommonResponse.ok(result);
    }

    /**
     * 从OpenApiOrder+OpenApiOrderItem组装ReportParams
     */
    private ReportParams buildReportParams(OpenApiOrder order, List<OpenApiOrderItem> items) {
        String erpOrderType = resolveErpOrderType(order.getType(), order.getWkType());

        List<ReportDataParam> reportDataList = new ArrayList<>();
        for (int i = 0; i < dataArray.size(); i++) {
            JSONObject row = dataArray.getJSONObject(i);
            ReportDataParam dataParam = new ReportDataParam()
                    .setWMSNO(pickString(row, "WMSNO", "wmsNo", "orderNo", "OrderNo"))
                    .setPONO(pickString(row, "PONO", "poNo"))
                    .setOrderNO(pickString(row, "OrderNO", "orderNo"))
                    .setGoodsNO(pickString(row, "GoodsNO", "goodsNo", "batch", "Batch"))
                    .setItemCode(pickString(row, "ItemCode", "itemCode", "matNr", "MatNr"))
                    .setEditUser(pickString(row, "EditUser", "editUser"))
                    .setMemoDtl(pickString(row, "MemoDtl", "memoDtl", "memo"));

            BigDecimal inQty = pickDecimal(row, "InQty", "inQty");
            BigDecimal outQty = pickDecimal(row, "OutQty", "outQty");
            if (Objects.nonNull(inQty) && inQty.compareTo(ZERO) > 0) {
                dataParam.setInQty(inQty.doubleValue());
        for (OpenApiOrderItem item : items) {
            BigDecimal qty = defaultQty(item.getQty());
            if (qty.compareTo(ZERO) <= 0) {
                continue;
            }
            if (Objects.nonNull(outQty) && outQty.compareTo(ZERO) > 0) {
                dataParam.setOutQty(outQty.doubleValue());

            ReportDataParam dataParam = new ReportDataParam()
                    .setWMSNO(order.getCode())
                    .setPONO(order.getPoCode())
                    .setOrderNO(order.getCode())
                    .setGoodsNO(item.getBatch())
                    .setItemCode(item.getMatnrCode())
                    .setEditUser("schedule")
                    .setEditDate(new Date())
                    .setMemoDtl(item.getMemo());

            if ("in".equalsIgnoreCase(order.getType())) {
                dataParam.setInQty(qty.doubleValue());
            } else {
                dataParam.setOutQty(qty.doubleValue());
            }

            reportDataList.add(dataParam);
        }

        return new ReportParams()
                .setOrderType(orderType)
                .setOrderType(erpOrderType)
                .setAction("Update")
                .setData(reportDataList);
    }

    /**
     * 根据type和wkType解析ERP上报的订单类型
     */
    private String resolveErpOrderType(String type, String wkType) {
        if (StringUtils.isBlank(wkType)) {
            return "in".equalsIgnoreCase(type) ? "PO_Instock" : "WO_Outstock";
        }
        switch (wkType) {
            case "PUR_ReceiveBill": return "PO_Instock";
            case "PUR_MRB": return "PR_Outstock";
            case "PRD_ReturnMtrl": return "WR_Instock";
            case "PRD_PickMtrl": return "WO_Outstock";
            case "PRD_FeedMtrl": return "WR_Instock_BL";
            case "PRD_INSTOCK":
            case "PRD_MORPT": return "WO_Outstock";
            case "STK_MISCELLANEOUS": return "In_Instock";
            case "STK_MisDelivery": return "Io_Outstock";
            default:
                return "in".equalsIgnoreCase(type) ? "PO_Instock" : "WO_Outstock";
        }
    }

    private OpenApiOrder saveOpenApiOrder(Order order) {
@@ -573,6 +634,7 @@
                .setQty(ZERO)
                .setWorkQty(ZERO)
                .setExceStatus(0)
                .setNtyStatus(0)
                .setStatus(1)
                .setBusinessTime(businessTime)
                .setOrderInternalCode(order.getOrderInternalCode())
@@ -736,43 +798,43 @@
        return merged;
    }

    private boolean existsReportEvent(String eventId, String taskNo, String reportNo) {
        return openApiOrderReportEventMapper.selectCount(new LambdaQueryWrapper<OpenApiOrderReportEvent>()
                .eq(OpenApiOrderReportEvent::getEventId, defaultString(eventId))
                .eq(OpenApiOrderReportEvent::getTaskNo, defaultString(taskNo))
                .eq(OpenApiOrderReportEvent::getReportNo, defaultString(reportNo))
                .eq(OpenApiOrderReportEvent::getStatus, 1)) > 0;
    }

    private OpenApiOrderReportEvent saveReportEvent(String eventId, String taskNo, String reportNo, String orderCode, String payload) {
        OpenApiOrderReportEvent event = new OpenApiOrderReportEvent()
                .setEventId(defaultString(eventId))
                .setTaskNo(defaultString(taskNo))
                .setReportNo(defaultString(reportNo))
                .setOrderCode(orderCode)
                .setPayload(payload)
                .setStatus(0);
        openApiOrderReportEventMapper.insert(event);
        return event;
    }

    private int allocateMergedDoneQty(String orderNo, String matnrCode, String batch, BigDecimal mergedDoneQty) {
        OpenApiOrder order = openApiOrderMapper.selectOne(new LambdaQueryWrapper<OpenApiOrder>()
                .eq(OpenApiOrder::getCode, orderNo)
                .last("limit 1"));
    private int allocateMergedDoneQty(String orderNo, String matnrCode, String batch, String lineId, BigDecimal mergedDoneQty, Map<String, OpenApiOrder> orderCache) {
        OpenApiOrder order = orderCache.computeIfAbsent(orderNo, k ->
                openApiOrderMapper.selectOne(new LambdaQueryWrapper<OpenApiOrder>()
                        .eq(OpenApiOrder::getCode, k)
                        .last("limit 1")));
        if (Objects.isNull(order)) {
            throw new CoolException("未找到订单：" + orderNo);
        }

        LambdaQueryWrapper<OpenApiOrderItemMap> queryWrapper = new LambdaQueryWrapper<OpenApiOrderItemMap>()
                .eq(OpenApiOrderItemMap::getOrderId, order.getId())
                .eq(OpenApiOrderItemMap::getMergeMatnrCode, defaultString(matnrCode))
                .orderByAsc(OpenApiOrderItemMap::getSeqNo)
                .orderByAsc(OpenApiOrderItemMap::getId);
        if (StringUtils.isNotBlank(batch)) {
            queryWrapper.eq(OpenApiOrderItemMap::getMergeBatch, batch);

        // 优先用lineId精确匹配原始行
        if (StringUtils.isNotBlank(lineId)) {
            queryWrapper.eq(OpenApiOrderItemMap::getSourceLineId, lineId);
        } else {
            queryWrapper.eq(OpenApiOrderItemMap::getMergeMatnrCode, defaultString(matnrCode));
            if (StringUtils.isNotBlank(batch)) {
                queryWrapper.eq(OpenApiOrderItemMap::getMergeBatch, batch);
            }
        }

        List<OpenApiOrderItemMap> mappingRows = openApiOrderItemMapMapper.selectList(queryWrapper);
        if (mappingRows.isEmpty() && StringUtils.isNotBlank(lineId)) {
            // lineId匹配不到时，回退到matNr+batch匹配
            queryWrapper = new LambdaQueryWrapper<OpenApiOrderItemMap>()
                    .eq(OpenApiOrderItemMap::getOrderId, order.getId())
                    .eq(OpenApiOrderItemMap::getMergeMatnrCode, defaultString(matnrCode))
                    .orderByAsc(OpenApiOrderItemMap::getSeqNo)
                    .orderByAsc(OpenApiOrderItemMap::getId);
            if (StringUtils.isNotBlank(batch)) {
                queryWrapper.eq(OpenApiOrderItemMap::getMergeBatch, batch);
            }
            mappingRows = openApiOrderItemMapMapper.selectList(queryWrapper);
        }
        if (mappingRows.isEmpty()) {
            throw new CoolException("未找到映射关系，订单：" + orderNo + "，物料：" + matnrCode);
        }
@@ -798,7 +860,7 @@
            openApiOrderItemMapMapper.updateById(row);
            openApiOrderItemMapper.update(null, new LambdaUpdateWrapper<OpenApiOrderItem>()
                    .eq(OpenApiOrderItem::getId, row.getSourceItemId())
                    .setSql("qty = IFNULL(qty,0) + " + toAllocate));
                    .setSql("qty = IFNULL(qty,0) + " + toAllocate.toPlainString()));
            remaining = remaining.subtract(toAllocate).setScale(2, RoundingMode.HALF_UP);
            allocateRows++;
        }
@@ -820,8 +882,22 @@
                .eq(OpenApiOrderItemMap::getOrderId, order.getId())
                .orderByAsc(OpenApiOrderItemMap::getSeqNo)
                .orderByAsc(OpenApiOrderItemMap::getId));
        int successCount = 0;

        // 批量查询所有 sourceItemId 对应的 OpenApiOrderItem，消除 N+1
        List<Long> itemIds = mappings.stream()
                .map(OpenApiOrderItemMap::getSourceItemId)
                .filter(Objects::nonNull)
                .distinct()
                .toList();
        Map<Long, OpenApiOrderItem> itemMap = new HashMap<>();
        if (!itemIds.isEmpty()) {
            List<OpenApiOrderItem> items = openApiOrderItemMapper.selectBatchIds(itemIds);
            for (OpenApiOrderItem item : items) {
                itemMap.put(item.getId(), item);
            }
        }

        int successCount = 0;
        for (OpenApiOrderItemMap mapping : mappings) {
            BigDecimal allocatedQty = defaultQty(mapping.getAllocatedQty());
            BigDecimal reportedQty = defaultQty(mapping.getReportedQty());
@@ -830,7 +906,7 @@
                continue;
            }

            OpenApiOrderItem item = openApiOrderItemMapper.selectById(mapping.getSourceItemId());
            OpenApiOrderItem item = itemMap.get(mapping.getSourceItemId());
            if (Objects.isNull(item)) {
                continue;
            }