package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.R;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.InOutCountDto;
import com.zy.asrs.entity.result.StockVo;
import com.zy.asrs.mapper.ReportQueryMapper;
import com.zy.asrs.mapper.TagMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.MatUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.DetlDto;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.NodeUtils;
import com.zy.system.entity.User;
import com.zy.system.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

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

    @Value("${u8.url}")
    private String url;

    @Value("${u8.path}")
    private String orderReportPath;


    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private MatService matService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private PackService packService;
    @Autowired
    private TagService tagService;
    @Autowired
    private TagMapper tagMapper;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private NodeService nodeService;
    @Autowired
    private ManLocDetlService manLocDetlService;
    @Autowired
    private ManPakOutService manPakOutService;
    @Autowired
    private LocOwnerService locOwnerService;
    @Autowired
    private ReportQueryMapper reportQueryMapper;
    @Autowired
    private UserService userService;
    @Autowired
    private PlaService plaService;
    @Autowired
    private ApiLogService apiLogService;

    @Override
    @Transactional
    public void pakinOrderCreate(OpenOrderPakinParam param) {
        Order order = orderService.selectByNo(param.getOrderNo());
        if (!Cools.isEmpty(order)) {
            throw new CoolException(param.getOrderNo() + "单据已存在，请勿重复提交");
        }

        for (DetlDto detlDto : param.getOrderDetails()) {
            if (Cools.isEmpty(detlDto) || Cools.isEmpty(detlDto.getOwnerName(), detlDto.getPayment())) {
                throw new CoolException(param.getOrderNo() + "缺少货主或货物形态");
            } else {
                LocOwner locOwner = locOwnerService.selectOne(new EntityWrapper<LocOwner>().eq("owner", detlDto.getOwnerName()));
                if (Cools.isEmpty(locOwner)) {
                    LocOwner locOwner1 = new LocOwner();
                    locOwner1.setOwner(detlDto.getOwnerName());
                    locOwnerService.insert(locOwner1);
                }
            }
        }
        DocType docType = docTypeService.selectOrAdd(param.getOrderType(), Boolean.TRUE);
        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(), detail.getOwnerName(), detail.getPayment());
            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);
            }
            dto.setWeight(detail.getWeight());
        }
        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);

            //批号为空会出现问题，设置一个默认值
            if (detlDto.getBatch() == null) {
                orderDetl.setBatch("");
            } else {
                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);
            LocOwner locOwner = locOwnerService.selectOne(new EntityWrapper<LocOwner>().eq("owner", detlDto.getOwnerName()));
            if (Cools.isEmpty(locOwner)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            } else {
                orderDetl.setOwner(locOwner.getId().intValue());
            }
            orderDetl.setPayment(detlDto.getPayment());
            orderDetl.setStatus(1);
            orderDetl.setQty(0.0D);
            orderDetl.setWeight(detlDto.getWeight());
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

    @Override
    @Transactional
    public void pakoutOrderCreate(OpenOrderPakoutParam param) {
        Order order = orderService.selectByNo(param.getCCode());
        // 如果单据不存在则添加；如果单据存在，作业中无法修改，反之则修改单据
        if (!Cools.isEmpty(order)) {
            if (order.getSettle() > 1L) {
                throw new CoolException(param.getCCode() + "正在出库，无法修改单据");
            }
            orderService.remove(order.getId());
        }
        DocType docType = docTypeService.selectOrAdd(param.getType(), Boolean.FALSE);
        Date now = new Date();

        //查找做单用户
        User user = userService.selectOne(new EntityWrapper<User>().eq("username", param.getCMaker()));
        if (Cools.isEmpty(user)) {
            throw new CoolException("未查询到该用户");
        }

        // 单据主档
        order = new Order(
                String.valueOf(snowflakeIdWorker.nextId()),    // 编号[非空]
                param.getCCode(),    // 订单编号
                DateUtils.convert(now),    // 单据日期
                docType.getDocId(),    // 单据类型
                1L,    // 项目编号
                null,    //
                null,    // 调拨项目编号
                null,    // 初始票据号
                param.getCAccount(),    // 主体
                null,    // 客户编号
                param.getCCusName(),    // 客户
                null,    // 联系方式
                param.getCMaker(),    // 操作人员
                null,    // 合计金额
                null,    // 优惠率
                null,    // 优惠金额
                null,    // 销售或采购费用合计
                null,    // 实付金额
                null,    // 付款类型
                null,    // 业务员
                null,    // 结算天数
                null,    // 邮费支付类型
                null,    // 邮费
                null,    // 付款时间
                null,    // 发货时间
                null,    // 物流名称
                null,    // 物流单号
                1L,    // 订单状态
                1,    // 状态
                user.getId(),    // 添加人员
                now,    // 添加时间
                9527L,    // 修改人员
                now,    // 修改时间
                null    // 备注
        );
        if (!orderService.insert(order)) {
            throw new CoolException("生成单据主档失败，请联系管理员");
        }
        // 单据明细档
        for (OpenOrderPakoutParam.Body body : param.getADDBody()) {
            Mat mat = matService.selectByMatnr(body.getCInvCode());
            if (Cools.isEmpty(mat)) {
                throw new CoolException(body.getCInvCode() + "编号商品检索失败，请先添加商品");
            }
            OrderDetl orderDetl = new OrderDetl();
            orderDetl.sync(mat);
            orderDetl.setAnfme(body.getIQuantity());
            orderDetl.setQty(0.0D);
            orderDetl.setWorkQty(0.0D);
            orderDetl.setStatus(1);
            orderDetl.setOrderId(order.getId());
            orderDetl.setOrderNo(order.getOrderNo());
            orderDetl.setCreateBy(user.getId());
            orderDetl.setCreateTime(now);
            orderDetl.setUpdateBy(user.getId());
            orderDetl.setUpdateTime(now);
            orderDetl.setUuid(String.valueOf(System.currentTimeMillis()));
            if (!orderDetlService.insert(orderDetl)) {
                throw new CoolException("生成单据明细失败，请联系管理员");
            }
        }
    }

    @Override
    @Transactional
    public List<StockVo> queryStock(StockVo stockVo) {
        return locDetlService.queryStockTotal(stockVo);
    }

    @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("商品数据为空");
        }

        //删除存货档案
        if (param.deleteFlag == 1) {
            for (MatSyncParam.MatParam matParam : param.getMatDetails()) {
                matService.deleteById(matParam.getMatnr());
            }

            return;
        }

        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(para);
//            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 (Cools.isEmpty(matParam.getLength()) || matParam.getLength() == 0) {
                    mat.setLength(null);
                }
                if (!matService.insert(mat)) {
                    throw new CoolException("服务器内部错误，请联系管理员");
                }
                log.info("同步新物料[商品编号：{}]", mat.getMatnr());
            } else {
                //mat.sync(param);
                mat.setMaktx(matParam.getMaktx());
                if (!matService.update(mat, new EntityWrapper<Mat>().eq("matnr", matParam.getMatnr()))) {
                    throw new CoolException("更新已存在商品信息失败，请联系管理员");
                }
                log.info("同步更新物料[商品编号：{}]", mat.getMatnr());
            }
        }

    }

    @Override
    public R getInOutDetl() {
        List<InOutCountDto> top100 = wrkMastService.selectTop100();
        return R.ok().add(top100);
    }

    /*
     * 速腾数字孪生调用接口
     * */
    @Override
    public DigitalTwin inventoryQuantity() {
        DigitalTwin digitalTwin = new DigitalTwin();
        LocChartPie locUseRate = reportQueryMapper.getLocUseRate();
        LocChartPie locUseRateL = reportQueryMapper.getLocUseRateL();
        LocChartPie locUseRateP = reportQueryMapper.getLocUseRateP();
        if (locUseRate != null) {
            digitalTwin.setCount(locUseRate.getOqty() + locUseRate.getFqty() + locUseRate.getUqty() + locUseRate.getXqty());
            digitalTwin.setOqty(locUseRate.getOqty());
            digitalTwin.setFqty(locUseRate.getFqty());
            digitalTwin.setUqty(locUseRate.getUqty());
            digitalTwin.setXqty(locUseRate.getXqty());
        }
        if (locUseRateL != null) {
            digitalTwin.setCountL(locUseRateL.getOqty() + locUseRateL.getFqty() + locUseRateL.getUqty() + locUseRateL.getXqty());
            digitalTwin.setOqtyL(locUseRateL.getOqty());
            digitalTwin.setFqtyL(locUseRateL.getFqty());
            digitalTwin.setUqtyL(locUseRateL.getUqty());
            digitalTwin.setXqtyL(locUseRateL.getXqty());
        }
        if (locUseRateP != null) {
            digitalTwin.setCountP(locUseRateP.getOqty() + locUseRateP.getFqty() + locUseRateP.getUqty() + locUseRateP.getXqty());
            digitalTwin.setOqtyP(locUseRateP.getOqty());
            digitalTwin.setFqtyP(locUseRateP.getFqty());
            digitalTwin.setUqtyP(locUseRateP.getUqty());
            digitalTwin.setXqtyP(locUseRateP.getXqty());
        }
        return digitalTwin;
    }

    @Override
    public int pakinReportErp(JSONObject json) throws ParseException {
        JSONArray jsonArray = JSONArray.parseArray(json.getJSONArray("pla").toJSONString());

        List<OpenOrderPakoutParam> list = new ArrayList<>();

        for (Object o : jsonArray) {
            JSONObject jsonObject = (JSONObject) o;
            String brand = jsonObject.get("brand").toString();
            String batch = jsonObject.get("batch").toString();
            Integer packageNo = Integer.parseInt(jsonObject.get("packageNo").toString());

            Pla pla = plaService.selectByBatchAndPackageNo(batch, packageNo, brand);
            Mat mat = matService.selectByMaktx(pla.getBrand());
            //当生产单号不一致时，需要新建一个param
            if (list.size() == 0 || checkOrder(list, pla.getProOrderNo()) == null) {
                OpenOrderPakoutParam param = new OpenOrderPakoutParam();
                param.setcMaker(json.get("user").toString());
                String type = Cools.isEmpty(pla.getProOrderNo()) ? "调拨入库单" : "产成品入库";
                param.setcCode(Cools.isEmpty(pla.getProOrderNo()) ? (new Date().getTime()) + "" : pla.getProOrderNo());
                param.setcAccount(pla.getWorkshop());
                param.setdDate(Utils.getDateStr(new Date()));
                param.setType(type);

                List<OpenOrderPakoutParam.Body> bodyList = new ArrayList<>();
                OpenOrderPakoutParam.Body body = new OpenOrderPakoutParam.Body();
                body.setcInvCode(mat.getMatnr());
                body.setiQuantity(pla.getWeightAnfme());
                body.setcBatch("");
                body.setCbMemo(pla.getMemo());
                bodyList.add(body);

                param.setaDDBody(bodyList);

                list.add(param);
            } else {
                OpenOrderPakoutParam param = checkOrder(list, pla.getProOrderNo());
                List<OpenOrderPakoutParam.Body> bodyList = param.getADDBody();
                OpenOrderPakoutParam.Body body = checkOrderDetl(bodyList, mat.getMatnr());
                //有新的牌号则添加新的orderDetl，否则累加
                if (body == null) {
                    body = new OpenOrderPakoutParam.Body();
                    body.setcInvCode(mat.getMatnr());
                    body.setiQuantity(pla.getWeightAnfme());
                    body.setCbMemo(pla.getMemo());
                    bodyList.add(body);
                } else {
                    body.setiQuantity(body.getIQuantity() + pla.getWeightAnfme());
                }
            }
        }

        //for (OpenOrderPakoutParam param : list) {
            doHttpRequest(list, "入库单上报", url, orderReportPath, null, "127.0.0.1");

        //}

        return 200;

        //return doHttpRequest(list, "入库单上报", url, orderReportPath, null, "127.0.0.1");

    }

    @Override
    public List<Order> selectOrderInformation(Map<String, String> param) {
        List<Order> list = new ArrayList<>();
        String name = param.get("name");
        User user = userService.selectOne(new EntityWrapper<User>().eq("username", name));
        if (Cools.isEmpty(user)) {
            return list;
        }
        List<Order> orderList = orderService.selectList(new EntityWrapper<Order>().eq("create_by", user.getId()));
        if (Cools.isEmpty(orderList)) {
            return list;
        }
        for (Order order : orderList) {
            if (order.getSettle() == 1 || order.getSettle() == 2) {
                List<OrderDetl> detlList = orderDetlService.selectByOrderId(order.getId());
                order.setOrderDetls(detlList);
                list.add(order);
            }
        }

        return list;
    }

    private OpenOrderPakoutParam checkOrder(List<OpenOrderPakoutParam> list, String orderNo) {

        for (OpenOrderPakoutParam param : list) {

            if (Cools.eq("调拨入库单", param.getType()) && Cools.isEmpty(orderNo)) {
                return param;
            }

            //判断是否包含重复的订单号
            if (Cools.eq(param.getCCode(), orderNo)) {
                return param;
            }
        }

        return null;

    }

    private OpenOrderPakoutParam.Body checkOrderDetl(List<OpenOrderPakoutParam.Body> bodyList, String matnr) {

        for (OpenOrderPakoutParam.Body param : bodyList) {
            //判断是否包含重复的订单号
            if (Cools.eq(param.getCInvCode(), matnr)) {
                return param;
            }
        }

        return null;

    }

    private int doHttpRequest(Object requestParam, String namespace, String url, String path, String appkey, String ip) {
        String response = "";
        boolean success = false;

        try {
            response = new HttpHandler.Builder()
                    .setUri(url)
                    .setPath(path)
                    .setJson(JSONObject.toJSONString(requestParam))
                    .build()
                    .doPost();
            log.info("入库单上报请求返回报文：{}", response);

            JSONObject jsonObject = JSON.parseObject(response);
            if (Cools.isEmpty(jsonObject.get("ErrorCode"))) {
                throw new CoolException(jsonObject.get("ErrorMsg").toString());
            }

            int code = Integer.parseInt(jsonObject.get("ErrorCode").toString());
            if (code != 0) {
                throw new CoolException(jsonObject.get("ErrorMsg").toString());
            }
            success = true;
            return code;
        } catch (Exception e) {
            log.error(e.getMessage());
            throw new CoolException(e.getMessage());
        } finally {
            apiLogService.save(
                    namespace,
                    url + path,
                    appkey,
                    ip,
                    JSON.toJSONString(JSONObject.toJSONString(requestParam)),
                    response,
                    success
            );
        }

    }


}