udi-wms-third-java/src/main/java/com/glxp/mipsdl/client/ctqyy/CtqyyClient.java

package com.glxp.mipsdl.client.ctqyy;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ReflectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.glxp.mipsdl.client.CommonHttpClient;
import com.glxp.mipsdl.config.ThirdSysConfig;
import com.glxp.mipsdl.constant.ConstantType;
import com.glxp.mipsdl.constant.Constants;
import com.glxp.mipsdl.dao.auth.AuthUserDao;
import com.glxp.mipsdl.dao.auth.AuthWarehouseDao;
import com.glxp.mipsdl.dao.auth.AuthWarehouseUserMapper;
import com.glxp.mipsdl.dao.basic.BasicBussinessTypeDao;
import com.glxp.mipsdl.dao.basic.BasicCorpDao;
import com.glxp.mipsdl.dao.basic.BasicProductsDao;
import com.glxp.mipsdl.dao.basic.BasicUdirelDao;
import com.glxp.mipsdl.dao.inout.*;
import com.glxp.mipsdl.dao.system.SysParamConfigMapper;
import com.glxp.mipsdl.dao.thrsys.ThrInvWarehouseDao;
import com.glxp.mipsdl.dao.thrsys.ThrProductsDao;
import com.glxp.mipsdl.dao.thrsys.ThrSystemBusApiDao;
import com.glxp.mipsdl.entity.auth.AuthUserEntity;
import com.glxp.mipsdl.entity.auth.AuthWarehouseEntity;
import com.glxp.mipsdl.entity.basic.BasicBussinessTypeEntity;
import com.glxp.mipsdl.entity.basic.BasicCorpEntity;
import com.glxp.mipsdl.entity.basic.BasicProductsEntity;
import com.glxp.mipsdl.entity.basic.BasicUdirelEntity;
import com.glxp.mipsdl.entity.ctqyy.BasicSkPrescribeItemEntity;
import com.glxp.mipsdl.entity.ctqyy.MaterialDictEntity;
import com.glxp.mipsdl.entity.ctqyy.PriceClassEntity;
import com.glxp.mipsdl.entity.ctqyy.ThrHslbEntity;
import com.glxp.mipsdl.entity.inout.*;
import com.glxp.mipsdl.entity.system.SysParamConfigEntity;
import com.glxp.mipsdl.entity.thrsys.ThrInvWarehouseEntity;
import com.glxp.mipsdl.entity.thrsys.ThrProductsEntity;
import com.glxp.mipsdl.entity.thrsys.ThrSystemBusApiEntity;
import com.glxp.mipsdl.http.HttpClient;
import com.glxp.mipsdl.req.base.*;
import com.glxp.mipsdl.req.ctqyy.*;
import com.glxp.mipsdl.req.post.*;
import com.glxp.mipsdl.req.zaxyy.ZaxzyyOrderRequest;
import com.glxp.mipsdl.req.zzzyy.ZzzyyRequest;
import com.glxp.mipsdl.res.BaseResponse;
import com.glxp.mipsdl.res.ctqyy.CtBaseResponse;
import com.glxp.mipsdl.res.udiwms.*;
import com.glxp.mipsdl.service.auth.AuthWarehouseService;
import com.glxp.mipsdl.service.order.OrderUploadLogService;
import com.glxp.mipsdl.service.system.SysParamConfigService;
import com.glxp.mipsdl.service.thrsys.ThrCorpService;
import com.glxp.mipsdl.service.thrsys.ThrSystemDetailService;
import com.glxp.mipsdl.util.DateUtil;
import com.glxp.mipsdl.util.IntUtil;
import com.glxp.mipsdl.util.ResultVOUtils;
import com.glxp.mipsdl.util.SubmitOrderUtil;
import lombok.extern.slf4j.Slf4j;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

@Slf4j
@Service(value = "100011HttpClient")
public class CtqyyClient extends CommonHttpClient {
    @Resource
    AuthWarehouseUserMapper authWarehouseUserMapper;
    @Resource
    private ThrSystemDetailService thrSystemDetailService;
    @Resource
    private HttpClient httpClient;

    @Resource
    private SubmitOrderUtil submitOrderUtil;
    @Resource
    private IoOrderUploadLogDao orderUploadLogDao;

    @Resource
    private IoOrderDao orderDao;
    @Resource
    private ThrSystemBusApiDao thrSystemBusApiDao;
    @Resource
    private BasicBussinessTypeDao basicBussinessTypeDao;
    @Resource
    private BasicCorpDao basicCorpDao;
    @Resource
    private IoCodeDao codeDao;
    @Resource
    private AuthWarehouseDao authWarehouseDao;
    @Resource
    private ThrInvWarehouseDao thrInvWarehouseDao;
    @Resource
    private AuthWarehouseService authWarehouseService;
    @Resource
    private ThirdSysConfig thirdSysConfig;
    @Resource
    private ThrCorpService thrCorpService;
    @Resource
    private IoOrderDetailBizDao orderDetailBizDao;
    @Resource
    private IoOrderDetailCodeDao orderDetailCodeDao;
    @Resource
    private AuthUserDao authUserDao;
    @Resource
    BasicUdirelDao basicUdirelDao;
    @Resource
    BasicProductsDao basicProductsDao;
    @Resource
    private OrderUploadLogService orderUploadLogService;

    /**
     * 拼接xml请求头
     *
     * @param methodName 方法名
     * @return
     */
    public String getMsgHeader(String methodName) {
        return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                "<root>" +
                "<serverName>" +
                methodName +
                "</serverName>" +
                "</root>";
    }


    public String parserResult(String response) {
        if (response.contains("<root")) {
            try {
                Document document = DocumentHelper.parseText(response);
                String message = document.getRootElement().element("message").getText();
                return message;
            } catch (DocumentException e) {
                log.info("解析长泰区医院智业接口返回结果异常, 返回结果：{}", response);
                log.error("异常信息：", e);
            }
        }
        return response;
    }


    @Override
    public BaseResponse getUnit(UdiwmsUnitRequest udiwmsUnitRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getMaterialUnit"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(udiwmsUnitRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URL_NAME_CORP_URL), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析漳州中医院智业接口返回往来单位字典数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }

    @Override
    public BaseResponse getProducts(UdiwmsProductRequest udiwmsProductRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getMaterialDict"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(udiwmsProductRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URL_NAME_PI_QUERY_URL), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            Map map = (Map) baseResponse.getData();
            List<ZzzyyProductsResponse> zzzyyProductsResponse = JSON.parseArray(map.get("list") + "", ZzzyyProductsResponse.class);
            for (ZzzyyProductsResponse productsResponse : zzzyyProductsResponse) {
                //判断要是规格和型号一致就是取规格 不一致就合并
                if (StrUtil.isNotEmpty(productsResponse.getModel_number()) && StrUtil.isNotEmpty(productsResponse.getStandard())) {
                    if (productsResponse.getModel_number().equals(productsResponse.getStandard())) {
                        productsResponse.setStandard(productsResponse.getStandard());
                    } else {
                        productsResponse.setStandard(productsResponse.getStandard() + productsResponse.getModel_number());
                    }
                } else if (StrUtil.isNotEmpty(productsResponse.getModel_number()) && StrUtil.isBlank(productsResponse.getStandard())) {
                    productsResponse.setStandard(productsResponse.getModel_number());
                }
            }
            map.put("list", JSON.toJSON(zzzyyProductsResponse));
            baseResponse.setData("");
            baseResponse.setData(map);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析漳州中医院智业接口返回产品信息字典数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }

    @Override
    public BaseResponse getOrderTypes(UdiwmsBusTypeRequest udiwmsBusTypeRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getMaterialType"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(udiwmsBusTypeRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URL_NAME_BUS_TYPE_QUERY_URL), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析漳州中医院智业接口返回单据类型数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }

    /**
     * 提交关联产品更新
     *
     * @return
     */
    @Override
    public BaseResponse postRelProduct(PostRelProductRequest postThrInvProductsRequest) {
        UdiRelevanceResponse udiRelevanceResponse = postThrInvProductsRequest.getUdiRelevanceResponse();

        if (udiRelevanceResponse == null) {
            return ResultVOUtils.error(500, "提交产品列表不能为空！");
        }
        MaterialDictEntity materialDictEntity = new MaterialDictEntity();
        if (StrUtil.isEmpty(udiRelevanceResponse.getMainId()) && StrUtil.isNotEmpty(udiRelevanceResponse.getOriginUuid()))
            materialDictEntity.setOperatType("1");
        else
            materialDictEntity.setOperatType("2");
        materialDictEntity.setMaterialName(udiRelevanceResponse.getCpmctymc());
        materialDictEntity.setCostlySign("1");
        materialDictEntity.setMaterialMasterCode(udiRelevanceResponse.getNameCode());
        materialDictEntity.setHisMaterialCode(udiRelevanceResponse.getMainId());
        materialDictEntity.setMaterialSpec(udiRelevanceResponse.getGgxh());
        materialDictEntity.setMaterialUnit(udiRelevanceResponse.getMeasname());
        //暂无区分进货价，零售价
        materialDictEntity.setImportPrice(udiRelevanceResponse.getPrice() == null ? "0" : udiRelevanceResponse.getPrice().toString());
        materialDictEntity.setRetailPrice(udiRelevanceResponse.getPrice() == null ? "0" : udiRelevanceResponse.getPrice().toString());
        materialDictEntity.setFactoryName(udiRelevanceResponse.getManufactory());
        materialDictEntity.setSupplierName(udiRelevanceResponse.getSupName());
        materialDictEntity.setInsuranceCode(udiRelevanceResponse.getYbbm());
        materialDictEntity.setRegeditNo(udiRelevanceResponse.getZczbhhzbapzbh());
        materialDictEntity.setMaterialClass(udiRelevanceResponse.getBasicPrductRemak7());
        //暂无中标标识
        materialDictEntity.setPublicFlag("1");
        materialDictEntity.setPriceItemClass(udiRelevanceResponse.getBasicPrductRemak8());
        //暂无收费标志
        materialDictEntity.setFeeFlag(udiRelevanceResponse.getBasicPrductRemak6());


        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("addMaterialDict"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(materialDictEntity));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URL_NAME_PRODUCT_SUBMIT_URL), ctqyyRequest);
        response = parserResult(response);
        try {
            log.error("提交新增产品信息：" + ctqyyRequest.getMsgBody());
            CtBaseResponse baseResponse = JSONObject.parseObject(response, CtBaseResponse.class);
            if (baseResponse.getCode() != 20000) {
                String errMsg = "提交新增产品信息，异常：{}" + response;
                log.error(errMsg);
                return ResultVOUtils.error(500, "提交新增产品失败！");

            } else {
//                materialDictEntity.setMaterialNo(baseResponse.getMaterialNo());
                log.error("提交新增产品信息，成功：{}", response);
                return ResultVOUtils.success(baseResponse.getMaterialNo());
            }
        } catch (Exception e) {
            String errMsg = "提交新增产品信息，异常：{}" + response;
            log.error(errMsg);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, errMsg);

        }
    }


    /**
     * 获取患者信息
     *
     * @param getSickRequest
     * @return
     */
    public BaseResponse getSickInfo(GetSickRequest getSickRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getSickVisitInfo"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(getSickRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URI_GET_SICKER), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            Map map = (Map) baseResponse.getData();
            List<BasicSkSickerResponse> basicSkSickerResponses = JSON.parseArray(map.get("list") + "", BasicSkSickerResponse.class);
//            for (BasicSkSickerResponse productsResponse : basicSkSickerResponses) {
//
//            }
            map.put("list", JSON.toJSON(basicSkSickerResponses));
            baseResponse.setData("");
            baseResponse.setData(map);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析长泰医院智业返回病人信息数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }

    /**
     * 获取患者处方信息
     *
     * @param getSickPrescribeRequest
     * @return
     */
    public BaseResponse getSickPescribe(GetSickPrescribeRequest getSickPrescribeRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getResiPresInfo"));
        getSickPrescribeRequest.setResiNo(getSickPrescribeRequest.getAdNum());
        getSickPrescribeRequest.setAdNum(null);
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(getSickPrescribeRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URI_GET_SICKER_PRESCIRBE), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            Map map = (Map) baseResponse.getData();
            List<BasicSkPrescribeResponse> basicSkPrescribeResponses = JSON.parseArray(map.get("list") + "", BasicSkPrescribeResponse.class);
            for (BasicSkPrescribeResponse basicSkPrescribeResponse : basicSkPrescribeResponses) {
                List<BasicSkPrescribeItemEntity> itemEntities = basicSkPrescribeResponse.getItemList();
                if (CollUtil.isNotEmpty(itemEntities)) {
                    for (BasicSkPrescribeItemEntity itemEntity : itemEntities) {
                        itemEntity.setCount("0");
                    }
                }
            }
            map.put("list", JSON.toJSON(basicSkPrescribeResponses));
            baseResponse.setData("");
            baseResponse.setData(map);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析长泰医院智业返回处方信息数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }

    }


//    public String getStrConut(String str) {
//        if (StrUtil.isNotEmpty(str)) {
//            return "0";
//        }
//        Pattern pattern = Pattern.compile("\\d+");
//        Matcher matcher = pattern.matcher(str);
//        String strCount = "";
//        while (matcher.find()) {
//            strCount = strCount + matcher.group();
//        }
//        return strCount;
//    }


    /**
     * 获取项目组套字典
     *
     * @param dlThirdProjectRequest
     * @return
     */
    @Override
    public BaseResponse getBasicProject(DlThirdProjectRequest dlThirdProjectRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getMaterialDict"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(dlThirdProjectRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URI_GET_PROJECT), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            Map map = (Map) baseResponse.getData();
            List<BasicSkProjectResponse> basicSkProjectResponses = JSON.parseArray(map.get("list") + "", BasicSkProjectResponse.class);
            for (BasicSkProjectResponse basicSkProjectResponse : basicSkProjectResponses) {

            }
            map.put("list", JSON.toJSON(basicSkProjectResponses));
            baseResponse.setData("");
            baseResponse.setData(map);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析长泰医院智业返回项目信息数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }


    /**
     * 获取核算类别
     *
     * @param hslbRequest
     * @return
     */
    @Override
    public BaseResponse getHsfl(FilterThrHslbRequest hslbRequest) {
        CtqyyRequest ctqyyRequest = new CtqyyRequest();
        ctqyyRequest.setMsgHeader(getMsgHeader("getItemClass"));
        ctqyyRequest.setMsgBody(JSONUtil.toJsonStr(hslbRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URI_GET_HSLB), ctqyyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            Map map = (Map) baseResponse.getData();
            List<PriceClassEntity> priceClassEntities = JSON.parseArray(map.get("list") + "", PriceClassEntity.class);

            List<ThrHslbEntity> hslbEntities = new ArrayList<>();
            for (PriceClassEntity priceClassEntity : priceClassEntities) {
                ThrHslbEntity thrHslbEntity = new ThrHslbEntity();
                thrHslbEntity.setHsbm(priceClassEntity.getClassCode());
                thrHslbEntity.setHsmc(priceClassEntity.getClassName());
                hslbEntities.add(thrHslbEntity);
            }
            map.put("list", JSON.toJSON(hslbEntities));
            baseResponse.setData("");
            baseResponse.setData(map);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析长泰医院智业返回物价类别信息异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }


    @Override
    public BaseResponse getOrders(UdiwmsOrderQueryRequest udiwmsOrderQueryRequest) {
        return null;
    }

    @Resource
    SysParamConfigService sysParamConfigService;

    @Override
    public BaseResponse submitOrders(UdiwmsOrderRequest udiwmsOrderRequest) {
        if (StrUtil.isBlank(udiwmsOrderRequest.getBillNo())) {
            return ResultVOUtils.error(500, "单据号不能为空");
        }

        ZaxzyyOrderRequest zaxzyyOrderRequest = new ZaxzyyOrderRequest();
        BeanUtil.copyProperties(udiwmsOrderRequest, zaxzyyOrderRequest);
        //查询单据和详情信息，组装第三方系统接口所需参数
        IoOrderEntity orderEntity = orderDao.selectOne(new QueryWrapper<IoOrderEntity>().eq("billNo", udiwmsOrderRequest.getBillNo()));

        zaxzyyOrderRequest.setBillDate(DateUtil.formatDateTime(orderEntity.getCreateTime()));
        //查询对应的第三方单据类型
        ThrSystemBusApiEntity thrSystemBusApiEntity = thrSystemBusApiDao.selectOne(new QueryWrapper<ThrSystemBusApiEntity>().eq("code", udiwmsOrderRequest.getBillType()));
        zaxzyyOrderRequest.setThirdSys(getUserName(orderEntity));
        zaxzyyOrderRequest.setBillType(thrSystemBusApiEntity.getThirdBuyCode());
        zaxzyyOrderRequest.setBillFlag("1");

        //查询单据类型
        BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeDao.selectByAction(udiwmsOrderRequest.getBillType());
        if (basicBussinessTypeEntity.getCorpType().equals(Constants.CORP_HOSPTIAL)) {
            //医院客户
            zaxzyyOrderRequest.setCorpId(orderEntity.getFromCorp());
            //查询客户名称
            String corpName = basicCorpDao.selectNameByErpId(orderEntity.getFromCorp());
            zaxzyyOrderRequest.setCorpName(corpName);
        } else if (basicBussinessTypeEntity.getCorpType().equals(Constants.CORP_INTTERNAL)) {
            //内部科室
            BasicCorpEntity basicCorpEntity = null;
            if (StrUtil.isNotEmpty(orderEntity.getFromCorp())) {
                basicCorpEntity = basicCorpDao.selectByErpId(orderEntity.getFromCorp());
            }
            if (basicCorpEntity != null) {
                zaxzyyOrderRequest.setCorpId(basicCorpEntity.getThirdId());
                zaxzyyOrderRequest.setCorpName(basicCorpEntity.getName());
            } else {
                AuthWarehouseEntity warehouseEntity = authWarehouseDao.selectOne(new QueryWrapper<AuthWarehouseEntity>().eq("code", udiwmsOrderRequest.getCorpId()));
                try {
                    //根据第三方系统标识，获取对应字段的值
                    ThrInvWarehouseEntity thrInvWarehouseEntity = thrInvWarehouseDao.selectOne(new LambdaQueryWrapper<ThrInvWarehouseEntity>()
                            .eq(ThrInvWarehouseEntity::getCode, authWarehouseService.getThirdInvCode(warehouseEntity))
                            .eq(ThrInvWarehouseEntity::getThirdSysFk, thirdSysConfig.getThirdId()));

                    zaxzyyOrderRequest.setCorpId(thrInvWarehouseEntity.getCode());
                    zaxzyyOrderRequest.setCorpName(thrInvWarehouseEntity.getName());
                } catch (Exception e) {
                    String msg = "查询单据对应往来单位的第三方仓库信息异常";
                    orderUploadLogService.updateLocalErr(orderEntity, msg);
                    log.error("----单据提交-----" + orderEntity.getBillNo() + msg);
                    return ResultVOUtils.error(500, msg);
                }
            }

        } else {
            //供应商
            BasicCorpEntity basicCorpEntity = null;
            if (StrUtil.isNotEmpty(orderEntity.getFromCorp())) {
                basicCorpEntity = basicCorpDao.selectByErpId(orderEntity.getFromCorp());
            }
            if (basicCorpEntity != null) {
                zaxzyyOrderRequest.setCorpId(basicCorpEntity.getThirdId());
                zaxzyyOrderRequest.setCorpName(basicCorpEntity.getName());
            } else {
                String msg = "查询单据对应的第三方往来单位信息异常";
                orderUploadLogService.updateLocalErr(orderEntity, msg);
                log.error("----单据提交-----" + orderEntity.getBillNo() + msg);
                return ResultVOUtils.error(500, msg);
            }
        }


        //查询仓库信息
        AuthWarehouseEntity warehouseEntity = authWarehouseDao.selectOne(new QueryWrapper<AuthWarehouseEntity>().eq("code", orderEntity.getInvCode()));
        try {
            ThrInvWarehouseEntity thrInvWarehouseEntity = thrInvWarehouseDao.selectOne(new LambdaQueryWrapper<ThrInvWarehouseEntity>()
                    .eq(ThrInvWarehouseEntity::getCode, authWarehouseService.getThirdInvCode(warehouseEntity))
                    .eq(ThrInvWarehouseEntity::getThirdSysFk, thirdSysConfig.getThirdId()));

            zaxzyyOrderRequest.setLocInvCode(thrInvWarehouseEntity.getCode());
            zaxzyyOrderRequest.setLocInvName(thrInvWarehouseEntity.getName());

            zaxzyyOrderRequest.setLocStorageCode(thrInvWarehouseEntity.getCode());
            zaxzyyOrderRequest.setLocStorageName(thrInvWarehouseEntity.getName());
        } catch (Exception e) {
            log.error("查询第三方系统仓库信息异常", e);
        }

        //设置单据出入库类型
        if (basicBussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_PUT)) {
            zaxzyyOrderRequest.setInoutType(1); //入库
        } else if (basicBussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
            zaxzyyOrderRequest.setInoutType(2); //出库
        }

        //设置备注信息
        zaxzyyOrderRequest.setRemark("udi管理系统提交单据");
        //组装单据明细数据
        List<IoCodeEntity> ioCodeEntities = codeDao.selectList(new QueryWrapper<IoCodeEntity>()
                .eq("orderId", orderEntity.getBillNo())
                .ne("action", "StockCheck")
        );
        List<UdiwmsOrderDetailRequest> items = new ArrayList<>();
        //查询业务单据详情
        List<IoOrderDetailBizEntity> detailBizEntities = orderDetailBizDao.selectList(new QueryWrapper<IoOrderDetailBizEntity>().eq("orderIdFk", orderEntity.getBillNo()));
        setOrderDetailList(ioCodeEntities, items, detailBizEntities);
        zaxzyyOrderRequest.setItems(items);
        if (CollUtil.isEmpty(items)) {
            log.error("\"产品信息对照异常，无法上传\"");
            return ResultVOUtils.error(500, "产品信息对照异常，无法上传");
        }


        for (UdiwmsOrderDetailRequest i : items) {
            String fphm = "";
            String fprq = null;
            List<IoOrderInvoiceEntity> invoiceList = IoOrderInvoiceEntity.builder().build()
                    .selectList(Wrappers.lambdaQuery(IoOrderInvoiceEntity.class).eq(IoOrderInvoiceEntity::getOrderIdFk, orderEntity.getBillNo())
                            .eq(IoOrderInvoiceEntity::getBindRlFk, i.getBindRlFk())
                            .eq(StrUtil.isNotEmpty(i.getBatchNo()), IoOrderInvoiceEntity::getBatchNo, i.getBatchNo()).
                                    groupBy(IoOrderInvoiceEntity::getInvoiceEncode));
            if (CollectionUtil.isNotEmpty(invoiceList)) {
                fphm = invoiceList.stream().map(IoOrderInvoiceEntity::getInvoiceEncode).collect(Collectors.joining(","));
                if (invoiceList.get(0).getInvoiceDate() != null)
                    fprq = DateUtil.formatDateTime(invoiceList.get(0).getInvoiceDate());
            }
            i.setFirstSalesInvNo(fphm);
            i.setSecSalesInvNo(fphm);
            i.setInvoiceDate(fprq);
        }


        //构造诏安接口参数
        ZzzyyRequest zaZyRequest = new ZzzyyRequest();

        //提交到第三方系统
        if (thrSystemBusApiEntity.getUrl().equals("saveMasterialInput")) {
//            //采购入库单据
//            if (vailHightMaterial(detailBizEntities.get(0))) {
//                zaZyRequest.setMsgHeader(getMsgHeader("saveMaterialHight"));
//                UdiwmsPreInOrderRequest udiwmsPreInOrderRequest = submitPreInOrderToThirdSys(zaxzyyOrderRequest, orderEntity);
//                zaZyRequest.setMsgBody(JSONUtil.toJsonStr(udiwmsPreInOrderRequest));
//            } else {
//                zaZyRequest.setMsgHeader(getMsgHeader("saveMasterialInput"));
//                zaZyRequest.setMsgBody(JSONUtil.toJsonStr(zaxzyyOrderRequest));
//            }
            Boolean b = sysParamConfigService.selectByKey("ct_split_groupbuy");
            if (b) {
                Map<String, List<UdiwmsOrderDetailRequest>> splitMap = items.stream()
                        .collect(Collectors.groupingBy(UdiwmsOrderDetailRequest::getFirstSalesInvNo));
                BaseResponse baseResponse = null;
                int index = 1;
                if (splitMap.size() > 1) {
                    for (List<UdiwmsOrderDetailRequest> splitItems : splitMap.values()) {
                        zaxzyyOrderRequest.setItems(splitItems);
                        zaZyRequest.setMsgHeader(getMsgHeader("saveMasterialInput"));
                        zaZyRequest.setMsgBody(JSONUtil.toJsonStr(zaxzyyOrderRequest));
                        orderEntity.setBillNo(orderEntity.getBillNo() + "-" + index);
                        baseResponse = submitOrder(orderEntity, zaZyRequest);
                    }
                    return baseResponse;
                } else {
                    zaZyRequest.setMsgHeader(getMsgHeader("saveMasterialInput"));
                    zaZyRequest.setMsgBody(JSONUtil.toJsonStr(zaxzyyOrderRequest));
                    return submitOrder(orderEntity, zaZyRequest);
                }
            } else {
                zaZyRequest.setMsgHeader(getMsgHeader("saveMasterialInput"));
                zaZyRequest.setMsgBody(JSONUtil.toJsonStr(zaxzyyOrderRequest));
                return submitOrder(orderEntity, zaZyRequest);
            }


        } else if (thrSystemBusApiEntity.getUrl().equals("saveMaterialHight")) {

//            // 1.先提交到物资
//            zaZyRequest.setMsgHeader(getMsgHeader("saveMasterialInput"));
//            zaZyRequest.setMsgBody(JSONUtil.toJsonStr(zaxzyyOrderRequest));
//            submitOrder(orderEntity, zaZyRequest);


            //2.提交到预备货
            zaZyRequest.setMsgHeader(getMsgHeader("saveMaterialHight"));
            UdiwmsPreInOrderRequest udiwmsPreInOrderRequest = submitPreInOrderToThirdSys(zaxzyyOrderRequest, orderEntity);
            zaZyRequest.setMsgBody(JSONUtil.toJsonStr(udiwmsPreInOrderRequest));
            return submitOrder(orderEntity, zaZyRequest);
        }

        return ResultVOUtils.error(500, "提交失败！");
    }


    /**
     * 校验是否高值耗材
     *
     * @return
     */
    public boolean vailHightMaterial(IoOrderDetailBizEntity orderDetailBizEntity) {
        BasicUdirelEntity basicUdirel = basicUdirelDao.selectById(orderDetailBizEntity.getBindRlFk());
        BasicProductsEntity basicProductsEntity = basicProductsDao.selectOne(new QueryWrapper<BasicProductsEntity>().eq("uuid", basicUdirel.getUuid()).last("limit 1"));
        if (basicProductsEntity != null &&
                (StrUtil.trimToEmpty(basicProductsEntity.getBasicPrductRemak7()).equals("1101")
                        || StrUtil.trimToEmpty(basicProductsEntity.getBasicPrductRemak7()).equals("3601"))) {
            return true;
        } else
            return false;

    }


    public String getUserName(IoOrderEntity orderEntity) {

        return "黄跃祥/177";
//        String userName = null;
//        //创建人非供应商
//        if (StrUtil.isNotEmpty(orderEntity.getCheckUser())) {
//            AuthUserEntity authUserEntity = authUserDao.selectById(orderEntity.getCheckUser());
//            if (authUserEntity == null)
//                userName = null;
//            userName = authUserEntity.getUserName() + authUserEntity.getEmployeeName();
//        } else if (StrUtil.isNotEmpty(orderEntity.getReviewUser())) {
//            AuthUserEntity authUserEntity = authUserDao.selectById(orderEntity.getReviewUser());
//            userName = authUserEntity.getUserName() + authUserEntity.getEmployeeName();
//        } else if (StrUtil.isNotEmpty(orderEntity.getCreateUser()) && orderEntity.getCreateUser().length() != 14) {
//            AuthUserEntity authUserEntity = authUserDao.selectById(orderEntity.getCreateUser());
//            userName = authUserEntity.getUserName() + authUserEntity.getEmployeeName();
//        } else if (StrUtil.isNotEmpty(orderEntity.getUpdateUser()) && orderEntity.getUpdateUser().length() != 14) {
//            AuthUserEntity authUserEntity = authUserDao.selectById(orderEntity.getUpdateUser());
//            userName = authUserEntity.getUserName() + authUserEntity.getEmployeeName();
//        }
//        if (userName == null) {
//            List<AuthWarehouseUser> authWarehouseUsers = authWarehouseUserMapper.selectList(new QueryWrapper<AuthWarehouseUser>().eq("code", orderEntity.getInvCode()));
//            if (CollUtil.isNotEmpty(authWarehouseUsers)) {
//                AuthWarehouseUser authWarehouseUser = authWarehouseUsers.get(0);
//                AuthUserEntity authUserEntity = authUserDao.selectById(orderEntity.getCheckUser());
//                userName = authUserEntity.getUserName() + authUserEntity.getEmployeeName();
//                return userName;
//            }
//        }
//        return userName;

    }


    @Override
    public BaseResponse getInvProducts(UdiwmsInvProductsRequest udiwmsInvProductsRequest) {
        return null;
    }

    @Override
    public BaseResponse getWarehouse(UdiwmsWarehouseRequest udiwmsWarehouseRequest) {
        return null;
    }

    @Override
    public BaseResponse testConnect() {
        UdiwmsUnitRequest udiwmsUnitRequest = new UdiwmsUnitRequest();
        udiwmsUnitRequest.setPage(1);
        udiwmsUnitRequest.setLimit(1);
        BaseResponse baseResponse = getUnit(udiwmsUnitRequest);
        if (baseResponse.getCode() == 20000) {
            return ResultVOUtils.success("连接成功！");
        }
        return ResultVOUtils.error(500, "连接失败！");
    }

    @Override
    public BaseResponse queryUdiInvProducts(UdiwmsQueryUdiInvProductsRequest queryUdiInvProductsRequest) {
        return null;
    }

    @Override
    public BaseResponse submitProducts(UdiwmsAddProductsRequest udiwmsAddProductsRequest) {
        return null;
    }

    @Override
    public BaseResponse submitUnit(UdiwmsAddUnitRequest udiwmsAddUnitRequest) {
        return null;
    }

    @Override
    public BaseResponse postProducts(PostThrProductsRequest postThrProductsRequest) {
        return null;
    }

    @Override
    public BaseResponse postCorps(PostThrCorpRequest postThrCorpRequest) {
        return null;
    }

    @Override
    public BaseResponse postOrderDetail(PostFileThrOrderRequest postFileThrOrderRequest) {
        return null;
    }

    @Override
    public BaseResponse postInvProducts(PostThrInvProductsRequest postThrInvProductsRequest) {
        return null;
    }


    /**
     * 封装单据详情参数
     *
     * @param ioCodeEntities      单据码明细
     * @param orderDetailRequests 单据详情参数
     * @param detailBizEntities   单据业务详情
     */
    private void setOrderDetailList(List<IoCodeEntity> ioCodeEntities, List<UdiwmsOrderDetailRequest> orderDetailRequests, List<IoOrderDetailBizEntity> detailBizEntities) {
        for (IoOrderDetailBizEntity detailBizEntity : detailBizEntities) {

            IoOrderDetailCodeEntity orderDetailCodeEntity = orderDetailCodeDao
                    .selectOne(new QueryWrapper<IoOrderDetailCodeEntity>()
                            .eq("orderIdFk", detailBizEntity.getOrderIdFk())
                            .eq("bindRlFk", detailBizEntity.getBindRlFk())
                            .eq(StrUtil.isNotEmpty(detailBizEntity.getBatchNo()), "batchNo", detailBizEntity.getBatchNo())
                            .isNull(StrUtil.isEmpty(detailBizEntity.getBatchNo()), "batchNo").last("LIMIT 1"));
            if (orderDetailCodeEntity != null && IntUtil.value(orderDetailCodeEntity.getReCount()) > 0) {
                detailBizEntity.setCount(orderDetailCodeEntity.getReCount());
                UdiwmsOrderDetailRequest item = buildProductInfo(detailBizEntity);
                if (item != null) {
                    //封装条码信息
                    submitOrderUtil.setCodeList(ioCodeEntities, detailBizEntity, item);
                    orderDetailRequests.add(item);
                }
            }
        }
    }


    @Resource
    private ThrProductsDao thrProductsDao;

    public UdiwmsOrderDetailRequest buildProductInfo(IoOrderDetailBizEntity detailBizEntity) {
        //查询产品信息
        BasicUdirelEntity basicUdirel = basicUdirelDao.selectById(detailBizEntity.getBindRlFk());
        BasicProductsEntity basicProducts = basicProductsDao.selectOne(new LambdaQueryWrapper<BasicProductsEntity>().eq(BasicProductsEntity::getUuid, basicUdirel.getUuid()).last("limit 1"));

        UdiwmsOrderDetailRequest item = new UdiwmsOrderDetailRequest();
        BeanUtil.copyProperties(detailBizEntity, item);

        item.setProductDate(DateUtil.formatExpireTime(StrUtil.isBlank(detailBizEntity.getProductDate()) ? null : "20" + detailBizEntity.getProductDate()));
        item.setExpireDate(DateUtil.formatExpireTime(StrUtil.isBlank(detailBizEntity.getExpireDate()) ? null : "20" + detailBizEntity.getExpireDate()));

        String thirdProductId = (String) ReflectUtil.getFieldValue(basicUdirel, thirdSysConfig.getThirdId());
        item.setProductId(thirdProductId); //产品ID
        //查询第三方产品名称
        ThrProductsEntity thrProductsEntity = thrProductsDao.selectOne(new LambdaQueryWrapper<ThrProductsEntity>()
                .eq(ThrProductsEntity::getCode, thirdProductId).last("limit 1"));
        if (thrProductsEntity == null) {
            log.error("第三方产品编码未关联");
            return null;
        }
        item.setProductName(thrProductsEntity.getName()); //产品名称
        item.setBindRlFk(detailBizEntity.getBindRlFk());
        item.setStandard(detailBizEntity.getSpec()); //规格型号
        item.setBillNo(detailBizEntity.getOrderIdFk()); //单据号
        item.setRegisterNo(detailBizEntity.getCertCode()); //注册/备案证号
        item.setManufactory(basicProducts.getManufactory()); //生产厂家
        item.setMeasname(basicProducts.getMeasname()); //计量单位
        item.setAllowNoBatch(IntUtil.value(basicProducts.getAllowNoBatch())); //是否允许无批次号
//        item.setManufactoryCode(thrProductsEntity.getManufactoryCode());
        item.setSupCode(thrProductsEntity.getSupCode());
        item.setCplb(thrProductsEntity.getFlbm());
        item.setHslb(thrProductsEntity.getCplb());
        item.setCount(detailBizEntity.getCount());
        return item;
    }


    /**
     * 处理提交单据，记录日志，解析结果逻辑
     *
     * @param orderEntity
     * @param zaZyRequest
     * @return
     */
    private BaseResponse submitOrder(IoOrderEntity orderEntity, ZzzyyRequest zaZyRequest) {
        //记录日志
        IoOrderUploadLogEntity uploadLog = new IoOrderUploadLogEntity();
        uploadLog.setBillDate(orderEntity.getCreateTime());
        uploadLog.setBillType(orderEntity.getAction());
        uploadLog.setSubmitTime(new Date());
        uploadLog.setBillNo(orderEntity.getBillNo());
        uploadLog.setFromType(Constants.THIRD_ORDER_UPLOAD);
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URL_NAME_ORDER_SUBMIT_URL), zaZyRequest);
        response = parserResult(response);
        if (StrUtil.isNotBlank(response)) {
            try {
                BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
                if (baseResponse.getCode() == 20000) {
                    String thirdBillNo = String.valueOf(baseResponse.getData());
                    orderEntity.setThirdBillNo(thirdBillNo);
                    orderEntity.setExportStatus(1); //提交成功
                    uploadLog.setStatus(2);
                    uploadLog.setThrBillNo(thirdBillNo);
                    uploadLog.setResult("提交成功");
                    orderDao.updateById(orderEntity);
                    orderUploadLogDao.insert(uploadLog);
                    return ResultVOUtils.success("提交成功");
                }
                uploadLog.setStatus(3);
                uploadLog.setResult("提交失败，错误信息：" + baseResponse.getMessage());
                orderEntity.setExportStatus(2); //上传失败
                orderDao.updateById(orderEntity);
                orderUploadLogDao.insert(uploadLog);
                return baseResponse;
            } catch (Exception e) {
                log.error("解析提交到智业单据返回结果异常，结果信息：{}", response);
                log.error("异常信息：{}", e);
                uploadLog.setStatus(3);
                uploadLog.setResult("提交失败，错误信息：" + response);
                orderEntity.setExportStatus(2); //上传失败
                orderDao.updateById(orderEntity);
                orderUploadLogDao.insert(uploadLog);
                return ResultVOUtils.error(500, "提交失败");
            }
        } else {
            uploadLog.setStatus(3);
            uploadLog.setResult("提交失败，调用接口返回为空");
            orderEntity.setExportStatus(2); //上传失败
            orderDao.updateById(orderEntity);
            orderUploadLogDao.insert(uploadLog);
            return ResultVOUtils.error(500, "提交失败");
        }
    }


    @Override
    public BaseResponse submitPreInOrders(UdiwmsPreInOrderRequest udiwmsPreInOrderRequest) {
        ZzzyyRequest zaZyRequest = new ZzzyyRequest();
        zaZyRequest.setMsgHeader(getMsgHeader("saveMaterialHight"));
        zaZyRequest.setMsgBody(JSONUtil.toJsonStr(udiwmsPreInOrderRequest));
        String response = httpClient.postJson(thrSystemDetailService.getUrlExclude(Constants.URL_NAME_PRE_IN_ORDER_SUBMIT_URL), zaZyRequest);
        response = parserResult(response);
        try {
            BaseResponse baseResponse = JSONObject.parseObject(response, BaseResponse.class);
            return baseResponse;
        } catch (Exception e) {
            log.error("解析漳州中医院智业接口提交单据返回数据异常，返回结果：{}", response);
            log.error("异常信息：{}", e);
            return ResultVOUtils.error(500, "网络错误，或远程服务器异常无法返回正确结果（" + response + ")");
        }
    }


    /**
     * 转换提交单据参数
     *
     * @param udiwmsOrderRequest
     * @param orderEntity
     * @return
     */
    public UdiwmsPreInOrderRequest submitPreInOrderToThirdSys(ZaxzyyOrderRequest udiwmsOrderRequest, IoOrderEntity orderEntity) {
        UdiwmsPreInOrderRequest udiwmsPreInOrderRequest = new UdiwmsPreInOrderRequest();
        if (udiwmsOrderRequest != null) {
            BeanUtils.copyProperties(udiwmsOrderRequest, udiwmsPreInOrderRequest);
            udiwmsPreInOrderRequest.setLocInvCode(udiwmsOrderRequest.getLocStorageCode());
            udiwmsPreInOrderRequest.setLocInvName(udiwmsOrderRequest.getLocStorageName());
            String deptCode = "70";
            if (StrUtil.isNotEmpty(orderEntity.getOriginUllageSupNo())) {
                IoOrderEntity temp = orderDao.selectOne(new QueryWrapper<IoOrderEntity>().eq("billNo", orderEntity.getOriginUllageSupNo()).last("limit 1"));
                if (temp != null && StrUtil.isNotEmpty(temp.getFromInvCode())) {
                    AuthWarehouseEntity authWarehouseEntity =
                            authWarehouseDao.selectOne(new QueryWrapper<AuthWarehouseEntity>().eq("code", temp.getFromInvCode()).last("limit 1"));
                    deptCode = authWarehouseEntity.getThirdId();
                }
            }
            udiwmsPreInOrderRequest.setDeptCode(deptCode);
            if (orderEntity.getReviewUser() != null) {
                AuthUserEntity authUser = authUserDao.selectById(orderEntity.getReviewUser());
                udiwmsPreInOrderRequest.setActor(authUser.getEmployeeName());
            } else if (orderEntity.getCreateUser() != null) {
                AuthUserEntity authUser = authUserDao.selectById(orderEntity.getCreateUser());
                udiwmsPreInOrderRequest.setActor(authUser.getEmployeeName());
            }
            List<UdiwmsPreInOrderRequest.ItemDTO> itemDTOS = new ArrayList<>();
            if (CollUtil.isNotEmpty(udiwmsOrderRequest.getItems())) {
                for (UdiwmsOrderDetailRequest udiwmsOrderDetail : udiwmsOrderRequest.getItems()) {
                    if (CollUtil.isNotEmpty(udiwmsOrderDetail.getCodeList())) {
                        for (UdiwmsOrderDetailRequest.CodeDetailEntity codeDetaiEntity : udiwmsOrderDetail.getCodeList()) {
                            UdiwmsPreInOrderRequest.ItemDTO itemDTO = new UdiwmsPreInOrderRequest.ItemDTO();
                            BeanUtils.copyProperties(udiwmsOrderDetail, itemDTO);

                            String code = codeDetaiEntity.getCode();
                            if (code.contains("\u001D")) {
                                code = code.replace("\u001D", "zysoft");
                            }
                            itemDTO.setCode(code);
                            itemDTO.setCount(codeDetaiEntity.getCount());
                            itemDTO.setNameCode(codeDetaiEntity.getNameCode());
                            itemDTOS.add(itemDTO);

                        }
                    }
                }
            }
            udiwmsPreInOrderRequest.setItems(itemDTOS);
        }
        return udiwmsPreInOrderRequest;
    }
}