#lfderp接口开发

lty

2 天以前 264a479aa1ad16818110e9f9d833bbf02e298f47

 src/main/java/com/zy/asrs/service/impl/OpenServiceImpl.java

@@ -1,29 +1,44 @@
package com.zy.asrs.service.impl;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.DocType;
import com.zy.asrs.entity.Mat;
import com.zy.asrs.entity.Order;
import com.zy.asrs.entity.OrderDetl;
import com.zy.asrs.entity.param.OpenOrderCompleteParam;
import com.zy.asrs.entity.param.OpenOrderPakinParam;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.OpenOrderCompeteResult;
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.service.ErpMatService;
import com.zy.asrs.service.ErpOrderService;
import com.zy.asrs.service.ErpOrderDetlService;
import com.zy.asrs.utils.MatUtils;
import com.zy.common.model.DetlDto;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.NodeUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by vincent on 2022/4/9
 */
@Slf4j
@Service
public class OpenServiceImpl implements OpenService {

@@ -39,7 +54,22 @@
    private MatService matService;
    @Autowired
    private LocDetlService locDetlService;

    @Autowired
    private PackService packService;
    @Autowired
    private TagService tagService;
    @Autowired
    private TagMapper tagMapper;
    @Autowired
    private ErpMatService erpMatService;
    @Autowired
    private ErpOrderService erpOrderService;
    @Autowired
    private ErpOrderDetlService erpOrderDetlService;
    @Autowired
    private ApiLogService apiLogService;
    @Autowired
    private PlatformTransactionManager transactionManager;
    @Override
    @Transactional
    public void pakinOrderCreate(OpenOrderPakinParam param) {
@@ -47,7 +77,7 @@
        if (!Cools.isEmpty(order)) {
            throw new CoolException(param.getOrderNo() + "单据已存在，请勿重复提交");
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType());
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
        Date now = new Date();
        // 单据主档
        order = new Order(
@@ -109,6 +139,8 @@
            }
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(mat);
            orderDetl.setBatch(detlDto.getBatch());
            orderDetl.setAnfme(detlDto.getAnfme());
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
@@ -124,8 +156,183 @@
    }

    @Override
    public Object pakinOrderComplete(OpenOrderCompleteParam param) {
        return null;
    @Transactional
    public List<OpenOrderCompeteResult> pakinOrderComplete(OpenOrderCompleteParam param) {
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
            Order order = orderService.selectByNo(param.getOrderNo());
            if (null != order) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                }
                if (order.getSettle() == 4L) {
                    // 修改订单状态 4.完成 ===>> 6.已上报
                    if (!orderService.updateSettle(order.getId(), 6L, null)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            for (Order order : orders) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                }
                // 修改订单状态 4.完成 ===>> 6.已上报
                if (!orderService.updateSettle(order.getId(), 6L, null)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
        }
        return results;
    }

    @Override
    @Transactional
    public void pakoutOrderCreate(OpenOrderPakoutParam param) {
        Order order = orderService.selectByNo(param.getOrderNo());
        // 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
        if (!Cools.isEmpty(order)) {
            if (order.getSettle() > 1L) {
                throw new CoolException(param.getOrderNo() + "正在出库，无法修改单据");
            }
            orderService.remove(order.getId());
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.FALSE);
        Date now = new Date();
        // 单据主档
        order = new Order(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getOrderNo(),    // 订单编号
                DateUtils.convert(now),    // 单据日期
                docType.getDocId(),    // 单据类型
                null,    // 项目编号
                null,    //
                null,    // 调拨项目编号
                null,    // 初始票据号
                null,    // 票据号
                null,    // 客户编号
                null,    // 客户
                null,    // 联系方式
                null,    // 操作人员
                null,    // 合计金额
                null,    // 优惠率
                null,    // 优惠金额
                null,    // 销售或采购费用合计
                null,    // 实付金额
                null,    // 付款类型
                null,    // 业务员
                null,    // 结算天数
                null,    // 邮费支付类型
                null,    // 邮费
                null,    // 付款时间
                null,    // 发货时间
                null,    // 物流名称
                null,    // 物流单号
                1L,    // 订单状态
                1,    // 状态
                9527L,    // 添加人员
                now,    // 添加时间
                9527L,    // 修改人员
                now,    // 修改时间
                null    // 备注
        );
        if (!orderService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
        List<DetlDto> list = new ArrayList<>();
        List<DetlDto> orderDetails = param.getOrderDetails();
        for (DetlDto detail : orderDetails) {
            DetlDto dto = new DetlDto(detail.getMatnr(), detail.getBatch(), detail.getAnfme());
            if (DetlDto.has(list, dto)) {
                DetlDto detlDto = DetlDto.find(list, dto.getMatnr(), dto.getBatch());
                assert detlDto != null;
                detlDto.setAnfme(detlDto.getAnfme() + detail.getAnfme());
            } else {
                list.add(dto);
            }
        }
        for (DetlDto detlDto : list) {
            Mat mat = matService.selectByMatnr(detlDto.getMatnr());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(detlDto.getMatnr() + "编号商品检索失败，请先添加商品");
            }
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(mat);
            orderDetl.setBatch(detlDto.getBatch());
            orderDetl.setAnfme(detlDto.getAnfme());
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(9527L);
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(9527L);
            orderDetl.setUpdateTime(now);
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

    @Override
    public List<OpenOrderCompeteResult> pakoutOrderComplete(OpenOrderCompleteParam param) {
        List<OpenOrderCompeteResult> results = new ArrayList<>();
        if (!Cools.isEmpty(param) && !Cools.isEmpty(param.getOrderNo())) {
            // 指定订单
            Order order = orderService.selectByNo(param.getOrderNo());
            if (null != order) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                }
                if (order.getSettle() == 4L) {
                    // 修改订单状态 4.完成 ===>> 6.已上报
                    if (!orderService.updateSettle(order.getId(), 6L, null)) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
            }
        } else {
            // 所有订单
            List<Order> orders = orderService.selectList(new EntityWrapper<Order>().eq("settle", 4L));
            for (Order order : orders) {
                OpenOrderCompeteResult result = new OpenOrderCompeteResult();
                results.add(result);
                result.setOrderNo(order.getOrderNo());
                result.setOrderTime(order.getOrderTime());
                result.setOrderType(order.getDocType$());
                List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
                for (OrderDetl orderDetl : orderDetls) {
                    result.getOrderDetails().add(new DetlDto(orderDetl.getOrderNo(), orderDetl.getMatnr(), orderDetl.getBatch(), orderDetl.getQty()));
                }
                // 修改订单状态 4.完成 ===>> 6.已上报
                if (!orderService.updateSettle(order.getId(), 6L, null)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
            }
        }
        return results;
    }

    @Override
@@ -134,4 +341,755 @@
        return locDetlService.queryStockTotal();
    }

    @Override
    @Transactional
    public void packageUp(PackParam param) {
        if (Cools.isEmpty(param.getBarcode())) {
            throw new CoolException("barcode不能为空");
        }
        Mat analyse = MatUtils.analyseMat(param.getBarcode());
        Pack pack = packService.selectByBarcode(param.getBarcode());
        if (null != pack) {
            throw new CoolException(param.getBarcode() + "重复提交");
        }
        Date now = new Date();
        pack = new Pack(
                param.getBarcode(),    // 条码[非空]
                analyse.getMatnr(),    // 商品编号
                analyse.getBarcode(),    // 序列码
                1L,    // 订单状态
                1,    // 状态
                now,    // 添加时间
                null,    // 添加人员
                now,    // 修改时间
                null,    // 修改人员
                null    // 备注
        );
        if (!packService.insert(pack)) {
            throw new CoolException("服务器内部错误，请联系管理员");
        }

        Mat mat = matService.selectByMatnr(analyse.getMatnr());
        if (mat == null) {
            mat = new Mat();
            // 分类
            Long tagId;
            // 一级分类
            if (!Cools.isEmpty(param.getGroupCode()) && !Cools.isEmpty(param.getGroupName())) {
                Tag priTag = tagService.selectByName(param.getGroupCode(), 2);
                if (priTag == null) {
                    Tag top = tagService.getTop();
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(top.getId());
                    priTag = new Tag(
                            null,    // 编号
                            param.getGroupCode(),    // 名称
                            top.getId(),    // 父级
                            top.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            2,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            null    // 备注
                    );
                    if (tagMapper.insert(priTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
                // 二级分类
                Tag secTag = tagService.selectByName(param.getGroupName(), 3);
                if (secTag == null) {
                    NodeUtils nodeUtils = new NodeUtils();
                    nodeUtils.executePath(priTag.getId());
                    secTag = new Tag(
                            null,    // 编号
                            param.getGroupName(),    // 名称
                            priTag.getId(),    // 父级
                            priTag.getName(),    // 父级名称
                            nodeUtils.path.toString(),    // 关联路径
                            nodeUtils.pathName.toString(),    // 关联路径名
                            0,    // 类型
                            null,    // 负责人
                            null,    // 图片
                            null,    // 简要描述
                            null,    // 数量
                            3,    // 等级
                            null,    // 排序
                            1,    // 状态
                            now,    // 添加时间
                            null,    // 添加人员
                            now,    // 修改时间
                            null,    // 修改人员
                            null    // 备注
                    );
                    if (tagMapper.insert(secTag) == 0) {
                        throw new CoolException("服务器内部错误，请联系管理员");
                    }
                }
                tagId = secTag.getId();
            } else {
                tagId = tagService.getTop().getId();
            }
            mat.setTagId(tagId);
            mat.setMatnr(analyse.getMatnr());
            mat.setMaktx(param.getMaterialName());
            mat.setSpecs(param.getConfigureDesc());
            mat.setModel(analyse.getModel());
            mat.setStatus(1);
            mat.setCreateTime(now);
            mat.setUpdateTime(now);
            if (!matService.insert(mat)) {
                throw new CoolException("服务器内部错误，请联系管理员");
            } else {
                log.info("打包上线添加新物料[商品编号：{}]", mat.getMatnr());
            }
        }
    }

    @Override
    @Transactional
    public void syncMat(MatSyncParam param) {
        if (Cools.isEmpty(param.getMatDetails()) || param.getMatDetails().size() <=0 ) {
            throw new CoolException("商品数据为空");
        }

        for(MatSyncParam.MatParam matParam : param.getMatDetails()){
            if(Cools.isEmpty(matParam.getMatnr())){
                throw new CoolException("商品编码不能为空");
            }

            Date now = new Date();
            Mat mat = matService.selectByMatnr(matParam.getMatnr());
            if (mat == null) {
                mat = new Mat();
                // 分类
                Long tagId;
                // 一级分类
                if (!Cools.isEmpty(matParam.getGroupCode()) && !Cools.isEmpty(matParam.getGroupName())) {
                    Tag priTag = tagService.selectByName(matParam.getGroupCode(), 2);
                    if (priTag == null) {
                        Tag top = tagService.getTop();
                        NodeUtils nodeUtils = new NodeUtils();
                        nodeUtils.executePath(top.getId());
                        priTag = new Tag(
                                null,    // 编号
                                matParam.getGroupCode(),    // 名称
                                top.getId(),    // 父级
                                top.getName(),    // 父级名称
                                nodeUtils.path.toString(),    // 关联路径
                                nodeUtils.pathName.toString(),    // 关联路径名
                                0,    // 类型
                                null,    // 负责人
                                null,    // 图片
                                null,    // 简要描述
                                null,    // 数量
                                2,    // 等级
                                null,    // 排序
                                1,    // 状态
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                null    // 备注
                        );
                        if (tagMapper.insert(priTag) == 0) {
                            throw new CoolException("服务器内部错误，请联系管理员");
                        }
                    }
                    // 二级分类
                    Tag secTag = tagService.selectByName(matParam.getGroupName(), 3);
                    if (secTag == null) {
                        NodeUtils nodeUtils = new NodeUtils();
                        nodeUtils.executePath(priTag.getId());
                        secTag = new Tag(
                                null,    // 编号
                                matParam.getGroupName(),    // 名称
                                priTag.getId(),    // 父级
                                priTag.getName(),    // 父级名称
                                nodeUtils.path.toString(),    // 关联路径
                                nodeUtils.pathName.toString(),    // 关联路径名
                                0,    // 类型
                                null,    // 负责人
                                null,    // 图片
                                null,    // 简要描述
                                null,    // 数量
                                3,    // 等级
                                null,    // 排序
                                1,    // 状态
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                null    // 备注
                        );
                        if (tagMapper.insert(secTag) == 0) {
                            throw new CoolException("服务器内部错误，请联系管理员");
                        }
                    }
                    tagId = secTag.getId();
                } else {
                    tagId = tagService.getTop().getId();
                }
                mat.sync(matParam);
//            mat.setMatnr(param.getMatnr());
//            mat.setMaktx(param.getMaktx());
//            mat.setSpecs(param.getSpecs());
//            mat.setModel(param.getModel());

                mat.setTagId(tagId);
                mat.setStatus(1);
                mat.setCreateTime(now);
                mat.setUpdateTime(now);
                if (!matService.insert(mat)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                } else {
                    log.info("同步新物料[商品编号：{}]", mat.getMatnr());
                }
            } else {
                mat.sync(matParam);
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr",matParam.getMatnr()))) {
                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
                }
            }
        }

    }

    @Override
    @Transactional
    public void syncErpMat(List<Map<String, Object>> body) {
        if (Cools.isEmpty(body)) {
            return;
        }
        int count = 0;
        for (Map<String, Object> m : body) {
            Object matNrObj = m.get("matNr");
            Object makTxObj = m.get("makTx");
            if (Cools.isEmpty(matNrObj) || Cools.isEmpty(makTxObj)) {
                continue;
            }
            ErpMat erpMat = new ErpMat();
            erpMat.setMatNr(String.valueOf(matNrObj));
            erpMat.setMakTx(String.valueOf(makTxObj));
            Object groupIdObj = m.get("groupId");
            if (!Cools.isEmpty(groupIdObj)) {
                erpMat.setGroupId(String.valueOf(groupIdObj));
            }
            Object groupNameObj = m.get("groupName");
            if (!Cools.isEmpty(groupNameObj)) {
                erpMat.setGroupName(String.valueOf(groupNameObj));
            }
            Object specObj = m.get("spec");
            if (!Cools.isEmpty(specObj)) {
                erpMat.setSpec(String.valueOf(specObj));
            }
            Object modelObj = m.get("model");
            if (!Cools.isEmpty(modelObj)) {
                erpMat.setModel(String.valueOf(modelObj));
            }
            Object weightObj = m.get("weight");
            if (!Cools.isEmpty(weightObj)) {
                Double w = null;
                if (weightObj instanceof Number) {
                    w = ((Number) weightObj).doubleValue();
                } else {
                    try {
                        w = Double.valueOf(String.valueOf(weightObj));
                    } catch (Exception ignored) {}
                }
                erpMat.setWeight(w);
            }
            Object colorObj = m.get("color");
            if (!Cools.isEmpty(colorObj)) {
                erpMat.setColor(String.valueOf(colorObj));
            }
            Object sizeObj = m.get("size");
            if (!Cools.isEmpty(sizeObj)) {
                erpMat.setSize(String.valueOf(sizeObj));
            }
            Object unitObj = m.get("unit");
            if (!Cools.isEmpty(unitObj)) {
                erpMat.setUnit(String.valueOf(unitObj));
            }
            Object describleObj = m.get("describle");
            if (!Cools.isEmpty(describleObj)) {
                erpMat.setDescribe(String.valueOf(describleObj));
            }
            Object wareHouseIdObj = m.get("wareHouseId");
            if (!Cools.isEmpty(wareHouseIdObj)) {
                erpMat.setWareHouseId(String.valueOf(wareHouseIdObj));
            }
            // 调用外部接口校验
            String syncError = null;
            String whId = erpMat.getWareHouseId();
            if (!Cools.isEmpty(whId)) {
                if ("WH01".equals(whId)) {
                    syncError = syncToWarehouse1(erpMat);
                } else if ("WH2".equals(whId)) {
                    syncError = syncToWarehouse2(erpMat);
                } else if ("WH3".equals(whId)) {
                    syncError = syncToWarehouse3(erpMat);
                } else {
                    callApiLogSave(null, null, "未找到对应仓库编码！！", true);
                    throw new CoolException("同步外部接口失败，仓库ID：" + whId + "，错误信息：未找到对应仓库编号"  );
                }
            }

            if (syncError != null) {
                // 如果同步失败，则不插入数据库，抛异常回滚或者跳过（当前逻辑为抛异常，因为是事务整体）
                // 若要部分成功，需要调整事务策略。这里假设要求全部成功。
                throw new CoolException("同步外部接口失败，仓库ID：" + whId + "，物料：" + erpMat.getMatNr() + "，错误信息：" + syncError);
            }

            Object operateTypeObj = m.get("operateType");
            if (!Cools.isEmpty(operateTypeObj)) {
                Integer ot = null;
                if (operateTypeObj instanceof Number) {
                    ot = ((Number) operateTypeObj).intValue();
                } else {
                    try {
                        ot = Integer.valueOf(String.valueOf(operateTypeObj));
                    } catch (Exception ignored) {}
                }
                erpMat.setOperateType(ot);
            }
            erpMat.setSendStatus(1);
            boolean ok = erpMatService.insert(erpMat);
            if (ok) {
                count++;
            }
        }
        if (count <= 0) {
            throw new CoolException("同步物料失败，无有效数据插入");
        }
    }

    // 模拟调用仓库1接口
    private String syncToWarehouse1(ErpMat mat) {
        log.info("Calling Warehouse 1 API for mat: {}", mat.getMatNr());
        return callMatSyncApi(mat, "http://localhost:8081");
    }

    // 模拟调用仓库2接口
    private String syncToWarehouse2(ErpMat mat) {
        log.info("Calling Warehouse 2 API for mat: {}", mat.getMatNr());
        return callMatSyncApi(mat, "http://localhost:8080");
    }

    // 模拟调用仓库3接口
    private String syncToWarehouse3(ErpMat mat) {
        log.info("Calling Warehouse 3 API for mat: {}", mat.getMatNr());
        return callMatSyncApi(mat, "http://localhost:8080");
    }

    private String callMatSyncApi(ErpMat mat, String baseUrl) {
        try {
            // 构造请求参数
            MatSyncParam param = new MatSyncParam();
            List<MatSyncParam.MatParam> list = new ArrayList<>();
            MatSyncParam.MatParam matParam = new MatSyncParam.MatParam();
            Date now = new Date();

            // 字段映射
            matParam.setMatnr(mat.getMatNr());
            matParam.setMaktx(mat.getMakTx());
            matParam.setSpecs(mat.getSpec());
            matParam.setModel(mat.getModel());
            matParam.setWeight(mat.getWeight());
            matParam.setColor(mat.getColor());
            matParam.setUnit(mat.getUnit());
            matParam.setMemo(mat.getDescribe());
            matParam.setGroupCode(mat.getGroupId());
            matParam.setGroupName(mat.getGroupName());
            
            list.add(matParam);
            param.setMatDetails(list);
            param.setCreateTime(String.valueOf(now));
            String path = "/lfdwms/open/asrs/order/matSync/default/v1";
            String json = JSON.toJSONString(param);

            Map<String, Object> headers = new HashMap<>();
            headers.put("appkey", "ea1f0459efc02a79f046f982767939ae");
            // headers.put("x-acgw-identity", "your_identity");
            String response = new HttpHandler.Builder()
                    .setHeaders(headers)
                    .setUri(baseUrl)
                    .setPath(path)
                    .setJson(json)
                    .build()
                    .doPost();
            
            if (Cools.isEmpty(response)) {
                return "接口无响应";
            }
            
            JSONObject jsonResponse = JSON.parseObject(response);
            if (jsonResponse == null) {
                return "接口响应格式错误";
            }
            
            // 根据实际返回结构判断成功失败
            // 假设 code == 0 或 200 为成功
            Integer code = jsonResponse.getInteger("code");
            if (code != null && (code == 0 || code == 200)) {
                return null; // 成功返回 null
            } else {
                return jsonResponse.getString("msg") != null ? jsonResponse.getString("msg") : "未知错误，code=" + code;
            }

        } catch (Exception e) {
            log.error("Call sync api error", e);
            return "接口调用异常：" + e.getMessage();
        }
    }

    @Override
    public Map<String, Object> addErpOrder(List<OrderDto> orders) {
        if (Cools.isEmpty(orders)) {
            Map<String, Object> res = new HashMap<>();
            res.put("result", "FAIL");
            res.put("successOrders", new ArrayList<>());
            res.put("failOrders", new ArrayList<>());
            res.put("successCount", 0);
            res.put("failCount", 0);
            return res;
        }

        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

        List<String> successOrders = new ArrayList<>();
        List<Map<String, Object>> failOrders = new ArrayList<>();

        for (OrderDto dto : orders) {
            String orderNo = dto != null ? dto.getOrderNo() : null;
            try {
                transactionTemplate.execute(status -> {
                    if (dto == null) {
                        throw new CoolException("订单参数不完整");
                    }
                    ErpOrder order = new ErpOrder();
                    order.setOrderNo(dto.getOrderNo());
                    order.setOrderType(dto.getOrderType());
                    order.setWkType(dto.getWkType());
                    order.setBusinessTime(dto.getBusinessTime());
                    order.setCreateTime(dto.getCreateTime());
                    order.setWarehouseId(dto.getWareHouseId());
                    order.setOperateType(dto.getOperateType());
                    order.setSendStatus(dto.getSendStatus() != null ? dto.getSendStatus() : 0);

                    List<ErpOrderDetl> detls = dto.getOrderItems();

                    if (Cools.isEmpty(order.getOrderNo()) || order.getOrderType() == null
                            || Cools.isEmpty(order.getWkType()) || order.getBusinessTime() == null || order.getCreateTime() == null
                            || Cools.isEmpty(order.getWarehouseId())) {
                        throw new CoolException("订单参数不完整");
                    }
                    if (Cools.isEmpty(detls)) {
                        throw new CoolException("订单明细为空");
                    }

                    String syncError = null;
                    String whId = order.getWarehouseId();
                    Integer orderType = order.getOrderType();

                    if (!Cools.isEmpty(whId)) {
                        if ("WH01".equals(whId)) {
                            syncError = syncOrderToWarehouse1(order, detls, orderType);
                        } else if ("WH2".equals(whId)) {
                            syncError = syncOrderToWarehouse2(order, detls, orderType);
                        } else if ("WH3".equals(whId)) {
                            syncError = syncOrderToWarehouse3(order, detls, orderType);
                        } else {
                            throw new CoolException("未找到对应仓库编号");
                        }
                    }

                    if (syncError != null) {
                        throw new CoolException(syncError);
                    }

                    if (!erpOrderService.insert(order)) {
                        throw new CoolException("订单插入失败");
                    }
                    if (order.getId() == null) {
                        throw new CoolException("订单插入失败，未返回orderId");
                    }

                    for (ErpOrderDetl detl : detls) {
                        if (detl == null || Cools.isEmpty(detl.getLineId()) || Cools.isEmpty(detl.getMatNr())
                                || Cools.isEmpty(detl.getMakTx()) || detl.getAnfme() == null) {
                            throw new CoolException("明细参数不完整");
                        }
                        detl.setOrderId(order.getId());
                        if (!erpOrderDetlService.insert(detl)) {
                            throw new CoolException("订单明细插入失败");
                        }
                    }
                    return null;
                });
                successOrders.add(orderNo);
            } catch (Exception e) {
                Map<String, Object> fail = new HashMap<>();
                fail.put("orderNo", orderNo);
                fail.put("msg", e.getMessage());
                failOrders.add(fail);
            }
        }

        Map<String, Object> res = new HashMap<>();
        res.put("successOrders", successOrders);
        res.put("failOrders", failOrders);
        res.put("successCount", successOrders.size());
        res.put("failCount", failOrders.size());
        res.put("result", failOrders.isEmpty() ? "SUCCESS" : (successOrders.isEmpty() ? "FAIL" : "PART_SUCCESS"));
        return res;
    }

    @Override
    public List<Map<String, Object>> mesInventoryDetails(Map<String, Object> param) throws IOException {
        String wareHouseId = param != null ? String.valueOf(param.get("wareHouseId")) : null;
        if ("null".equalsIgnoreCase(wareHouseId)) wareHouseId = null;

        List<String> whIds = new ArrayList<>();
        if (Cools.isEmpty(wareHouseId)) {
            whIds.add("WH01");
            whIds.add("WH02");
            whIds.add("WH03");
        } else {
            whIds.add(wareHouseId);
        }

        List<Map<String, Object>> result = new ArrayList<>();
        for (String whId : whIds) {
            String baseUrl = getWarehouseBaseUrl(whId);
            if (Cools.isEmpty(baseUrl)) {
                throw new CoolException("未找到对应仓库编号");
            }
            Map<String, Object> payload = param == null ? new HashMap<>() : new HashMap<>(param);
            payload.put("wareHouseId", whId);
            List<Map<String, Object>> data = callMesInventoryApi(baseUrl, "/lfdwms/open/asrs/MES/inventory/details", payload);
            if (!Cools.isEmpty(data)) {
                result.addAll(data);
            }
        }
        return result;
    }

    @Override
    public List<Map<String, Object>> mesInventorySummary(Map<String, Object> param) throws IOException {
        String wareHouseId = param != null ? String.valueOf(param.get("wareHouseId")) : null;
        if ("null".equalsIgnoreCase(wareHouseId)) wareHouseId = null;

        List<String> whIds = new ArrayList<>();
        if (Cools.isEmpty(wareHouseId)) {
            whIds.add("WH01");
            whIds.add("WH02");
            whIds.add("WH03");
        } else {
            whIds.add(wareHouseId);
        }

        List<Map<String, Object>> result = new ArrayList<>();
        for (String whId : whIds) {
            String baseUrl = getWarehouseBaseUrl(whId);
            if (Cools.isEmpty(baseUrl)) {
                throw new CoolException("未找到对应仓库编号");
            }
            Map<String, Object> payload = param == null ? new HashMap<>() : new HashMap<>(param);
            payload.put("wareHouseId", whId);
            List<Map<String, Object>> data = callMesInventoryApi(baseUrl, "/lfdwms/open/asrs/MES/inventory/summary", payload);
            if (!Cools.isEmpty(data)) {
                result.addAll(data);
            }
        }
        return result;
    }

    private String getWarehouseBaseUrl(String wareHouseId) {
        if (Cools.isEmpty(wareHouseId)) {
            return null;
        }
        String wh = wareHouseId.trim();
        if ("WH01".equalsIgnoreCase(wh) || "WH1".equalsIgnoreCase(wh)) {
            return "http://localhost:8081";
        }
        if ("WH02".equalsIgnoreCase(wh) || "WH2".equalsIgnoreCase(wh)) {
            return "http://localhost:8080";
        }
        if ("WH03".equalsIgnoreCase(wh) || "WH3".equalsIgnoreCase(wh)) {
            return "http://localhost:8080";
        }
        return null;
    }

    private List<Map<String, Object>> callMesInventoryApi(String baseUrl, String path, Map<String, Object> payload) throws IOException {
        String json = JSON.toJSONString(payload == null ? new HashMap<>() : payload);
        Map<String, Object> headers = new HashMap<>();
        headers.put("appkey", "ea1f0459efc02a79f046f982767939ae");
        String response = new HttpHandler.Builder()
                .setHeaders(headers)
                .setUri(baseUrl)
                .setPath(path)
                .setJson(json)
                .build()
                .doPost();

        if (Cools.isEmpty(response)) {
            throw new CoolException("接口无响应");
        }
        JSONObject jsonResponse = JSON.parseObject(response);
        if (jsonResponse == null) {
            throw new CoolException("接口响应格式错误");
        }
        Integer code = jsonResponse.getInteger("code");
        if (code != null && (code == 0 || code == 200)) {
            Object data = jsonResponse.get("data");
            if (data == null) {
                return new ArrayList<>();
            }
            if (data instanceof List) {
                return JSON.parseObject(JSON.toJSONString(data), List.class);
            }
            List<Map<String, Object>> list = new ArrayList<>();
            Map<String, Object> one = JSON.parseObject(JSON.toJSONString(data), Map.class);
            if (one != null) {
                list.add(one);
            }
            return list;
        }
        String msg = jsonResponse.getString("msg");
        throw new CoolException(!Cools.isEmpty(msg) ? msg : "未知错误，code=" + code);
    }

    // 模拟调用仓库1接口
    private String syncOrderToWarehouse1(ErpOrder order, List<ErpOrderDetl> details, Integer orderType) {
        log.info("Calling Warehouse 1 API for order: {}", order.getOrderNo());
        return callOrderSyncApi(order, details, orderType, "http://localhost:8081");
    }

    // 模拟调用仓库2接口
    private String syncOrderToWarehouse2(ErpOrder order, List<ErpOrderDetl> details, Integer orderType) {
        log.info("Calling Warehouse 2 API for order: {}", order.getOrderNo());
        return callOrderSyncApi(order, details, orderType, "http://localhost:8080");
    }

    // 模拟调用仓库3接口
    private String syncOrderToWarehouse3(ErpOrder order, List<ErpOrderDetl> details, Integer orderType) {
        log.info("Calling Warehouse 3 API for order: {}", order.getOrderNo());
        return callOrderSyncApi(order, details, orderType, "http://localhost:8080");
    }

    private String callOrderSyncApi(ErpOrder order, List<ErpOrderDetl> details, Integer orderType, String baseUrl) {
        try {
            // 根据 orderType 判断接口路径
            // 假设 1=出库，2=入库（请根据实际业务调整，这里按用户描述逻辑实现）
            // 用户描述：若是入库单则调用order/pakin/default/v1，若是出库order/pakout/default/v1
            // 假设 orderType 2 为入库，1 或 3 为出库（需确认 3 调拨单属于哪类，暂归为出库或不处理）
            
            String path;
            String json;
            
            if (orderType == 2) {
                // 入库单
                path = "/lfdwms/open/asrs/order/pakin/default/v1";
                OpenOrderPakinParam param = new OpenOrderPakinParam();
                param.setOrderNo(order.getOrderNo());
                // 这里可能需要映射 wkType 到 orderType 字符串，或者直接用
                param.setOrderType(order.getWkType()); 
                param.setOrderTime(DateUtils.convert(new Date(order.getBusinessTime())));
                
                List<DetlDto> detlDtos = new ArrayList<>();
                if (!Cools.isEmpty(details)) {
                    for (ErpOrderDetl d : details) {
                        DetlDto dto = new DetlDto();
                        dto.setMatnr(d.getMatNr());
                        // 如果有 batch 字段则设置，OpenOrderPakinParam 的 DetlDto 可能需要确认字段
                        dto.setBatch(d.getBatch());
                        dto.setAnfme(d.getAnfme() != null ? d.getAnfme().doubleValue() : 0.0);
                        // 其他字段映射...
                        detlDtos.add(dto);
                    }
                }
                param.setOrderDetails(detlDtos);
                json = JSON.toJSONString(param);
                
            } else if (orderType == 1 || orderType == 3) {
                // 出库单
                path = "/lfdwms/open/asrs/order/pakout/default/v1";
                OpenOrderPakoutParam param = new OpenOrderPakoutParam();
                param.setOrderNo(order.getOrderNo());
                param.setOrderType(order.getWkType());
                param.setOrderTime(DateUtils.convert(new Date(order.getBusinessTime())));
                param.setLgort("5006"); // 必填校验要求
                
                List<DetlDto> detlDtos = new ArrayList<>();
                if (!Cools.isEmpty(details)) {
                    for (ErpOrderDetl d : details) {
                        DetlDto dto = new DetlDto();
                        dto.setMatnr(d.getMatNr());
                        dto.setBatch(d.getBatch());
                        dto.setAnfme(d.getAnfme() != null ? d.getAnfme().doubleValue() : 0.0);
                        detlDtos.add(dto);
                    }
                }
                param.setOrderDetails(detlDtos);
                json = JSON.toJSONString(param);
            } else {
                return "未知的订单类型：" + orderType;
            }

            Map<String, Object> headers = new HashMap<>();
            headers.put("appkey", "ea1f0459efc02a79f046f982767939ae");
            String response = new HttpHandler.Builder()
                    .setHeaders(headers)
                    .setUri(baseUrl)
                    .setPath(path)
                    .setJson(json)
                    .build()
                    .doPost();
            
            if (Cools.isEmpty(response)) {
                return "接口无响应";
            }
            
            JSONObject jsonResponse = JSON.parseObject(response);
            if (jsonResponse == null) {
                return "接口响应格式错误";
            }
            
            Integer code = jsonResponse.getInteger("code");
            if (code != null && (code == 0 || code == 200)) {
                return null;
            } else {
                return jsonResponse.getString("msg") != null ? jsonResponse.getString("msg") : "未知错误，code=" + code;
            }

        } catch (Exception e) {
            log.error("Call order sync api error", e);
            return "接口调用异常：" + e.getMessage();
        }
    }
    public void callApiLogSave(Mat mat, String url, String response, Boolean bool) {
        apiLogService.save(
                "ERP同步物料信息",
                url,
                null,
                null,
                "物料编号：" + (mat != null ? mat.getMatnr() : null) +
                        "、物料名称：" + (mat != null ? mat.getMaktx() : null),
                response,
                bool
        );
    }
}