package com.vci.ubcs.code.service.impl;


import cn.hutool.json.XML;
import com.alibaba.fastjson.JSONObject;
import com.vci.ubcs.code.constant.MdmDuckingConstant;
import com.vci.code.dao.*;
import com.vci.code.model.*;
import com.vci.code.service.*;
import com.vci.code.utils.*;
import com.vci.starter.web.enumpck.UserSecretEnum;
import com.vci.starter.web.exception.VciBaseException;
import com.vci.starter.web.pagemodel.BaseResult;
import com.vci.starter.web.pagemodel.DataGrid;
import com.vci.starter.web.pagemodel.PageHelper;
import com.vci.starter.web.pagemodel.SessionInfo;
import com.vci.starter.web.util.VciBaseUtil;
import com.vci.starter.web.wrapper.VciQueryWrapperForDO;
import com.vci.ubcs.code.dao.*;
import com.vci.ubcs.code.model.*;
import com.vci.ubcs.code.service.*;
import com.vci.ubcs.code.utils.*;
import com.vci.web.pageModel.BatchCBO;
import com.vci.web.redis.RedisService;
import com.vci.web.service.WebBoServiceI;
import com.vci.web.util.PlatformClientUtil;
import com.vci.web.util.WebUtil;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.code.dao.*;
import com.vci.ubcs.code.dto.DockingPreApplyDataDTO;
import com.vci.ubcs.code.dto.DockingPreApplyDataInfoDTO;
import org.springblade.code.model.*;
import org.springblade.code.service.*;
import org.springblade.code.utils.*;
import com.vci.ubcs.code.vo.pagemodel.CodeClassifyTemplateVO;
import com.vci.ubcs.code.vo.pagemodel.SysIntInfoVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import plm.bs.bom.clientobject.ClientBusinessObject;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

import static com.vci.frameworkcore.constant.FrameWorkDefaultValueConstant.*;

/**
 * 主题库集成服务
 * @author wangyi
 * @date 2022-03-20
 */
@Service
public class CodeDuckingServiceImpl implements CodeDuckingServiceI {

    /**
     * 日志
     */
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 集成推送任务数据操作层
     */
    @Resource
    private DockingTaskDaoI dockingTaskDaoI;

    /**
     * 集成推送任务数据操作层
     */
    @Resource
    private DockingDataDaoI dockingDataDaoI;

    /**
     * 集成日志数据操作层
     */
    @Resource
    private DockingLogeDaoI dockingLogeDaoI;

    /**
     * 集成接口head数据操作层
     */
    @Resource
    private SysIntHeaderDaoI sysIntHeaderDaoI;

    /**
     * 模板属性数据操作层
     */
    @Resource
	@Lazy
    private CodeClassifyDaoI codeClassifyDaoI;


    /**
     * 业务类型操作的服务
     */
    @Autowired
    @Lazy
    private WebBoServiceI boService;

    /**
     * 缓存服务
     */
    @Autowired
    private RedisService redisService;

    /**
     * 数据服务
     */
    @Autowired(required = false)
    @Lazy
    private MdmEngineServiceI mdmEngineServiceI;

    /**
     * 编码预申请服务
     */
    @Autowired(required = false)
    @Lazy
    private DockingPreApplyDataServiceI dockingPreApplyDataServiceI;

    /**
     * 要推送系统的服务
     */
    @Autowired
    private SysIntInfoServiceI sysIntInfoServiceI;

    /**
     * 分类服务
     */
    @Autowired
    private CodeClassifyServiceI codeClassifyServiceI;


    @Value("${docking.tuhao:tuhao}")
    public String tuhao;

    @Value("${docking.tranTemp:D:\\PLT-2022\\web\\tranTemp}")
    public String tranTemp;

    @Value("${docking.preXmlTemp:D:\\PLT-2022\\web\\preXmlTemp}")
    public String preXmlTemp;

    /**
     * 二、1、2、3、4、
     * 处理预申请数据
     * @param xmlDatas
     * @return 接收的xmlDate
     */
    @Override
    public String applicateCode(String xmlDatas){

        long start = System.currentTimeMillis();

        Map<String,Object> datasMap = null;

        //解析xmlData
        try {
            datasMap = XmlUtil.readPreXmlData(xmlDatas);
        }catch (Exception e){
            logger.info("接收预申请数据，解析xmlData失败，xmlDatas: "+xmlDatas+",e: "+e.getMessage());
            e.printStackTrace();
            //返回提示
            return XmlUtil.writePreBackXmlData(MdmDuckingConstant.XML_CODE_FAIL,"解析xmlData失败,e: "+e.getMessage(),null);
        }

        List<XmlData> xmlDataList = Collections.synchronizedList(new ArrayList<XmlData>());
        String systemid = datasMap.getOrDefault(MdmDuckingConstant.XML_SYSTEMID,"").toString();
        List<Map<String,Object>> dataMapList = (ArrayList<Map<String,Object>>)datasMap.get(MdmDuckingConstant.XML_DATAS);

        //记录这次数据信息,并且把xmldata写入文件
        String currentDate = DateUtils.getCurrentDate(DateUtils.DATE_TO_STRING_DETAIAL_PATTERN);
        File preXmlFile = new File(preXmlTemp+ File.separator+systemid+"-"+currentDate+".xml");

        try {
            FileUtils.write(preXmlFile, xmlDatas);
        }catch (Exception e){
            logger.error(currentDate+" 接收"+systemid+"系统预申请数据，写入文件失败！e:"+e.getMessage()+",xmlDatas: "+xmlDatas);
            e.printStackTrace();
        }

        //处理每一条申请的数据
        ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()+1);

        SessionInfo sessionInfo = WebUtil.getSessionInfo();
        CountDownLatch countDownLatch = new CountDownLatch(dataMapList.size());
        for (int i =0;i<dataMapList.size();i++){
            Map<String,Object> dataMap = dataMapList.get(i);
            pool.execute(()-> {
                String unique = dataMap.getOrDefault(MdmDuckingConstant.XML_UNIQUE,"").toString();
                String type = dataMap.getOrDefault(MdmDuckingConstant.XML_TYPE,"").toString();

                //要插入的data
                DockingPreApplyDataDTO dockingPreApplyDataDO = new DockingPreApplyDataDTO();
                //要插入的datainfo
                List<DockingPreApplyDataInfoDTO> dockingPreApplyDataInfoDOList = new ArrayList<DockingPreApplyDataInfoDTO>();
                XmlData xmlData_ = new XmlData();

                try {
                    WebUtil.setSessionInfo(sessionInfo);

                    String num = "";
                    String datacode = "";
                    String datamsg = "";
                    String datamsglog = "";

                    //state=400，处理成功，没有找到编码
                    datamsg = "接收预申请数据，未查询到对应编码，赋码后推送编码信息";
                    datacode = MdmDuckingConstant.XML_STATE_400;
                    XmlData xmlData = new XmlData();
                    xmlData.setState(MdmDuckingConstant.XML_STATE_400);
                    xmlData.setMsg(datamsg);
                    xmlData.setUnique(unique);
                    xmlData.setNum(null);
                    logger.info(datamsg+"，data: "+dataMap.get(unique)+",num: ");
                    xmlData_ = xmlData;

                    //如果是MPM集成过来的数据，unique作为图号查询
                    if(MdmDuckingConstant.XML_SYSTEMID_MPM.equals(systemid)&& StringUtils.isNotEmpty(unique)) {

                        //1、先查询这个unique根据图号查询，有数据就就返回
                        Map conditonMap = new HashMap();
                        conditonMap.put("tuhao",unique);
//                        conditonMap.put("lcstatus",FRAMEWORK_RELEASE_RELEASED);
                        List<ClientBusinessObject> clientBusinessObjectList = boService.queryCBO(type,conditonMap);

                        if(clientBusinessObjectList.size()>0) {
                            num = clientBusinessObjectList.get(0).getId();
                            String lcstatus = clientBusinessObjectList.get(0).getLcStatus();
                            datamsg = "接收预申请数据，未查询到对应编码，赋码后推送编码信息";
                            if(FRAMEWORK_RELEASE_RELEASED.equals(lcstatus)) {
                                datamsg = "接收预申请数据，查询编码成功";
                                datamsglog = datamsg+"，data: " + dataMap.get(unique) + ",num: " + num;
                                datacode = MdmDuckingConstant.XML_STATE_200;

                            }else if(FRAMEWORK_RELEASE_SUBMIT.equals(lcstatus)){
                                datamsglog = datamsg+"，编码数据状态:已提交，data: " + dataMap.get(unique) + ",num: " + num;
                                datacode = MdmDuckingConstant.XML_STATE_400;

                            }else if(FRAMEWORK_RELEASE_AUDITING.equals(lcstatus)){
                                datamsglog = datamsg+"，编码数据状态:审核中，data: " + dataMap.get(unique) + ",num: " + num;
                                datacode = MdmDuckingConstant.XML_STATE_400;

                            }else if(FRAMEWORK_RELEASE_EDITING.equals(lcstatus)){
                                datamsglog = datamsg+"，编码数据状态:编辑中，data: " + dataMap.get(unique) + ",num: " + num;
                                datacode = MdmDuckingConstant.XML_STATE_400;

                            }else if(FRAMEWORK_DATA_DISABLED.equals(lcstatus)){
                                datamsglog = datamsg+"，编码数据状态:停用，data: " + dataMap.get(unique) + ",num: " + num;
                                datacode = MdmDuckingConstant.XML_STATE_400;
                            }
                            xmlData.setState(datacode);
                            xmlData.setMsg(datamsg);
                            xmlData.setUnique(unique);
                            xmlData.setNum(num);
                            logger.info(datamsglog);
                            xmlData_ = xmlData;
                        }
                    }
                    dockingPreApplyDataDO.setNum(num);
                    dockingPreApplyDataDO.setDatacode(datacode);
                    dockingPreApplyDataDO.setDatamsg(datamsg);

                    //2、根据unique查询DockingPreApplyDataDO，有数据就修改别的所有的usedflag=false,设置这个为true
                    //3、再插入DockingPreApplyDataDO和DockingPreApplyDataInfoDO
                    //其实，2、和3、这两步在dockingPreApplyDataServiceI.addSaveDataAndInfo（）这个方法中一起做了

                    String dataoid = redisService.getUUIDEveryDay();
//                    String dataoid = "1";
                    dockingPreApplyDataDO.setOid(dataoid);
                    dockingPreApplyDataDO.setPreapplyoid("1");
                    dockingPreApplyDataDO.setUniquecode(unique);
                    dockingPreApplyDataDO.setType(type);
                    dockingPreApplyDataDO.setSystemid(systemid);

                    Object attro = dataMap.get(MdmDuckingConstant.XML_PROS);

                    //要插入的datainfo
                    List<Map<String,String>> attrList = null;
                    if (attro == null) {
                        attrList = new ArrayList<Map<String,String>>();
                    }else {
                        attrList = (ArrayList<Map<String,String>>)attro;
                    }

                    String mpm_model = null;
                    String mpm_parttype = null;
                    String mpm_unit = null;
                    for (Map<String, String> attrMap : attrList) {
                        String datainfooid = redisService.getUUIDEveryDay();
//                      datainfooid = "1";
                        String key = attrMap.getOrDefault(MdmDuckingConstant.XML_KEY,"");
                        String mean = attrMap.getOrDefault(MdmDuckingConstant.XML_MEAN,"");
                        String text = attrMap.getOrDefault(MdmDuckingConstant.XML_TEXT,"");

                        DockingPreApplyDataInfoDTO dockingPreApplyDataInfoDO = new DockingPreApplyDataInfoDTO();
                        dockingPreApplyDataInfoDO.setDataoid(dataoid);
                        dockingPreApplyDataInfoDO.setOid(datainfooid);
                        dockingPreApplyDataInfoDO.setKey(key);
                        dockingPreApplyDataInfoDO.setValue(text);
                        dockingPreApplyDataInfoDO.setMean(mean);
                        dockingPreApplyDataInfoDOList.add(dockingPreApplyDataInfoDO);

                        //取三个值
                        if(MdmDuckingConstant.XML_MPM_MODEL.equals(key)){//取MPM规格
                            mpm_model = text;
                            dockingPreApplyDataDO.setModel(mpm_model);
                        }
                        if(MdmDuckingConstant.XML_MPM_PARTTYPE.equals(key)){//取MPM零件型号
                            mpm_parttype = text;
                            dockingPreApplyDataDO.setParttype(mpm_parttype);
                        }
                        if(MdmDuckingConstant.XML_MPM_UNIT.equals(key)){//单位
                            mpm_unit = text;
                            dockingPreApplyDataDO.setUnit(mpm_unit);
                        }
                    }

                    dockingPreApplyDataServiceI.addSaveDataAndInfo(dockingPreApplyDataDO, dockingPreApplyDataInfoDOList);

                } catch (Exception e) {
                    String datamsg = "接收预申请数据失败！，data: "+dataMap.get(unique)+",e: "+e.getMessage();
                    XmlData xmlData = new XmlData();
                    xmlData.setState(MdmDuckingConstant.XML_STATE_500);
                    xmlData.setMsg(datamsg);
                    xmlData.setUnique(unique);
                    xmlData.setNum(null);
                    logger.error(datamsg+".dockingPreApplyDataDO： "+dockingPreApplyDataDO+",dockingPreApplyDataInfoDOList: "+dockingPreApplyDataInfoDOList);
                    xmlData_ = xmlData;

                    e.printStackTrace();
                }finally {
                    xmlDataList.add(xmlData_);
                    countDownLatch.countDown();
                }
            });
        }

        //等待所有线程执行完成
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        String backXmlData = XmlUtil.writePreBackXmlData(MdmDuckingConstant.XML_CODE_SUCCESS,"接收预申请数据成功！",xmlDataList);


        long end = System.currentTimeMillis();

        //拼接返回的xmlData
        int dataMapSise = dataMapList.size();
        int xmlDataSise = xmlDataList.size();
        System.out.println("========================dataMapSise： "+dataMapSise+",xmlDataSise:"+xmlDataSise);

        System.out.println("========================处理预申请数据一共耗时 "+(end-start)/1000+"秒");
        return backXmlData;
    }

    /**
     * 四、1、2、3
     * 查询redis中数据，对比后插入dockingtask
     */
    @Override
    public void insertCache2(){

        initSysadmin();

        //sysintinfo查询要推送的主题库和相关系统信息
        Map<String, String> conditionMap = new HashMap<>();
        conditionMap.put("usedflag","true");
        List<SysIntInfoDO> sysIntInfoVOList = sysIntInfoServiceI.selectAll(conditionMap);

        //distinct出主题库btmname,存储key-value结构的分类数据，这里的分类是主题库root节点
        Set<String> btmtypeidSet = new HashSet<>();
        Map<String ,List<SysIntInfoDO>> sysIntInfoDOMap = new HashMap<String ,List<SysIntInfoDO>>();//key=classifyoid,value=list<map>
        for (SysIntInfoDO sysIntInfoVOi:sysIntInfoVOList){
            btmtypeidSet.add(sysIntInfoVOi.getBtmTypeId());
            List<SysIntInfoDO> SysIntInfoVOListi = sysIntInfoDOMap.get(sysIntInfoVOi.getClassifyoid());
            if(SysIntInfoVOListi==null){
                SysIntInfoVOListi = new ArrayList<SysIntInfoDO>();
            }
            SysIntInfoVOListi.add(sysIntInfoVOi);
            sysIntInfoDOMap.put(sysIntInfoVOi.getClassifyoid(),SysIntInfoVOListi);
        }

        //查询dockingdata:oid,classifyoid,btmid,btmoid,sendtype,classifyid,classifyname
//        List<Map> dataList = getDockingDatas();
        VciQueryWrapperForDO queryWrapperForDO = new VciQueryWrapperForDO(DockingDataDO.class);
        queryWrapperForDO.addQueryMap("sendflag","false");
        List<DockingDataDO> dataList = dockingDataDaoI.selectByWrapper(queryWrapperForDO);

        for (DockingDataDO mapi:dataList){

            WebUtil.setPersistence(false);
            BatchCBO batchCBO = new BatchCBO();

            String dataoid = mapi.getOid();//data对象的oid
            String classifyoid = mapi.getClassifyoid();
            String id = mapi.getId();
            String uniquecode = mapi.getUniquecode();
            String btmid = mapi.getBtmid();
            String btmoid = mapi.getBtmoid();
            String sendtype = mapi.getSendtype();
            String classifyid = mapi.getClassifyid();
            String classifyname = mapi.getClassifyname();

            //设置uniquecode
            if(StringUtils.isEmpty(uniquecode)){
                uniquecode = getTuhao(btmoid);//查询图号
                if(StringUtils.isNotEmpty(uniquecode)) {
                    updateDockingDatasUniqueCode(dataoid, uniquecode);
                }
            }
            List<SysIntInfoDO> effectiveSysIntInfoVOs=new ArrayList<>();
            String rootClassifyoid = "";
            String pushType="1";
            if(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equalsIgnoreCase(classifyoid)){//这个对应sysintinfo中的主题库id，如果是分类数据，就是DOCKING_DEFAULT_CLASSIFY=CODECLASSIFY
                rootClassifyoid = MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY;
                //判断是否属于分类树,如果是组织、人员、附录之类的不生成任务,并且自动清除这个data
                boolean iswupin = codeClassifyDaoI.isWupin(btmoid);
                if(!"TakeBack".equals(sendtype)&&!iswupin){
                    boolean u = delteDockingData(dataoid);
                    logger.error("集成data删除非分类data失败！dataoid:"+dataoid);
                    continue;
                }
                pushType="2";
                rootClassifyoid=btmoid;
            }else {
               /* CodeClassifyDO rootClassify = codeClassifyDaoI.getRootClassify(classifyoid);//root分类
                if(rootClassify==null){
                    continue;//说明这个分类被删掉了，不做处理
                }
                rootClassifyoid = rootClassify.getOid();*/
                rootClassifyoid=classifyoid;
            }

            List<CodeClassifyDO> parentLeveDO= codeClassifyDaoI.selectAllLevelParentByOid(rootClassifyoid);
            if(CollectionUtils.isEmpty(parentLeveDO)){
                continue;//说明这个分类被删掉了，不做处理
            }
            Map<String, CodeClassifyDO> oidCodeclassifyDOMap = parentLeveDO.stream().filter(codeClassifyDO -> codeClassifyDO != null && StringUtils.isNotBlank(codeClassifyDO.getOid())).collect(Collectors.toList()).stream().collect(Collectors.toMap(s -> s.getOid(), t -> t));
            String finalPushType = pushType;
            oidCodeclassifyDOMap.keySet().forEach(oid->{
                if(sysIntInfoDOMap.containsKey(oid)){
                    List<SysIntInfoDO> sysIntInfoDOS= sysIntInfoDOMap.get(oid);
                    sysIntInfoDOS.stream().forEach(sysIntInfoDO -> {
                        String sysPushType= sysIntInfoDO.getPushType();
                        if(sysPushType.equalsIgnoreCase(finalPushType)){
                            effectiveSysIntInfoVOs.add(sysIntInfoDO);
                        }
                    });


                }
            });
            if(CollectionUtils.isEmpty(effectiveSysIntInfoVOs)){
                continue;
            }
            List<DockingTaskDO> dockingTaskDO_insert = new ArrayList<DockingTaskDO>();
            for (SysIntInfoDO sysIntInfoVOi:effectiveSysIntInfoVOs){
               // String sysinfoclassifyoid = sysIntInfoVOi.getClassifyoid();//intinfo的classifyoid
               // if(!rootClassifyoid.equals(sysinfoclassifyoid)){
               //     continue;
              //  }
                DockingTaskDO dockingTaskDO = new DockingTaskDO();
                String oid=redisService.getUUIDEveryDay();
               // logger.error("===================================================oid: "+redisService.getUUIDEveryDay());
                dockingTaskDO.setOid(oid);
                dockingTaskDO.setSendflag(MdmDuckingConstant.SEND_FLAG_FALSE);
                dockingTaskDO.setId(id);//编码
                dockingTaskDO.setUniquecode(uniquecode);
                dockingTaskDO.setBtmoid(btmoid);//数据oid
                dockingTaskDO.setBtmid(btmid);//数据业务类型id
                dockingTaskDO.setClassifyid(classifyid);//数据在分类id
                dockingTaskDO.setClassifyoid(classifyoid);//数据所在分类oid
                dockingTaskDO.setClassifyname(classifyname);//数据所在分类名称
                dockingTaskDO.setSendtype(sendtype);//数据推送类型
                dockingTaskDO.setDataoid(dataoid);

                //intinfo
                dockingTaskDO.setSysinfooid(sysIntInfoVOi.getOid());//intinfo的oid
                dockingTaskDO.setSystemoid(sysIntInfoVOi.getSysbaseoid());//系统oid
                dockingTaskDO.setSystemcode(sysIntInfoVOi.getSysbaseid());//系统编码
                dockingTaskDO.setSystemname(sysIntInfoVOi.getSysbasename());//系统name

                dockingTaskDO_insert.add(dockingTaskDO);
            }

            BatchCBO bi = null;
            if(dockingTaskDO_insert.size()!=0) {
                bi = dockingTaskDaoI.batchInsert(dockingTaskDO_insert);
                batchCBO.copyFromOther(bi);
            }

            WebUtil.setPersistence(true);
            boService.persistenceBatch(batchCBO);

            //dockingTaskDaoI.updateByPrimaryKey方法报错了，所以手写了这个
            boolean u = updateDockingDatasSendFlag(dataoid, MdmDuckingConstant.SEND_FLAG_TRUE);
            if(!u){
                logger.error("集成data分解任务失败！dataoid:"+dataoid);
                continue;
            }

        }
    }

    /**
     * 四、3、
     * 1、
     */
    @Override
    public void sendData3(){

        initSysadmin();

        //查询哪些任务还没有执行完成
        VciQueryWrapperForDO queryWrapper = new VciQueryWrapperForDO(DockingTaskDO.class);
        queryWrapper.addQueryMap("sendFlag", MdmDuckingConstant.SEND_FLAG_FALSE);
        List<DockingTaskDO> dockingTaskDOS = dockingTaskDaoI.selectByWrapper(queryWrapper);

        //每个task依次执行推送
        for (DockingTaskDO dockingTaskDO:dockingTaskDOS){

            //每个task一个事务，开启
            WebUtil.setPersistence(false);
            BatchCBO batchCBO = new BatchCBO();

            String paramString = null;

            //查询系统接口信息,ip method,dataType
            String systeminfooid = dockingTaskDO.getSysinfooid();//sysininfo 的oid
            String systemcode = dockingTaskDO.getSystemcode();
            String systemname = dockingTaskDO.getSystemname();
            String systemoid = dockingTaskDO.getSystemoid();
            String dataid = dockingTaskDO.getId();//编码
            String uniquecode = dockingTaskDO.getUniquecode();//uniquecode

            //查询推送接口参数
            SysIntInfoVO sysIntInfoVO = sysIntInfoServiceI.getObjectByOid(systeminfooid);
            String url = sysIntInfoVO.getRequesturl();//url
            String type = sysIntInfoVO.getInterfacetype().toLowerCase(Locale.ROOT);//get/post/webserver/corba
            String paramType = sysIntInfoVO.getParamtype();//xml/json
            String returnType = sysIntInfoVO.getReturntype();//xml/json
            String interfaceFunction = sysIntInfoVO.getInterfaceFunction();//主要是webservice的方法名
            String namespace = sysIntInfoVO.getNamespace();//namespace
            String soapaction = sysIntInfoVO.getSoapaction();//soapaction
            String targName = sysIntInfoVO.getTargName();//targName
            String cxfaxis = sysIntInfoVO.getCxfaxis();//webservice是cxf/axis

            //查询param
            List<SysIntParamDO> sysIntParamDOList = sysIntInfoServiceI.getParamsBySystemInfoOid(systeminfooid);
            //查询header
            List<SysIntHeaderDO> sysIntHeaderDOList = sysIntInfoServiceI.getHeadersBySystemInfoOid(systeminfooid);

            //查询要推送的数据
            String btmoid = dockingTaskDO.getBtmoid();//数据oid
            String btmid = dockingTaskDO.getBtmid();//数据btmid
            String classifyoid = dockingTaskDO.getClassifyoid();
            String classifyid = dockingTaskDO.getClassifyid();
            String classifyname= dockingTaskDO.getClassifyname();
            String sendtype = dockingTaskDO.getSendtype();

            //组装数据
            XmlData xmlData = new XmlData();
            xmlData.setSendtype(sendtype);

            if(!MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equals(btmid)) {
                xmlData.setType(btmid);
            }

            String ret_xml = null;
            String id = null;
            String name = null;
            String idpath = null;
            String namepath = null;
            //表示是分类信息数据
            if(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equals(btmid)){
                xmlData.setNamepath("");
                xmlData.setIdpath("");
                xmlData.setNum("");

                CodeClassifyDO codeClassifyDO = null;
                try {
                    codeClassifyDO = codeClassifyDaoI.selectByPrimaryKey(btmoid);
                }catch (Exception e){

                }

                String classifyoid_parent = "";
                int orderNum = 0;
                if(codeClassifyDO==null){//查不到数据，说明被删除了，从DOCKING_CACHE2_DELETE取
                    CodeClassifyDO codeClassifyDOJson = (CodeClassifyDO)redisService.getCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE+btmoid);

                    if(codeClassifyDOJson==null){
                        BatchCBO insertLoge = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,"",url,"主数据系统未查询到删除的数据，未执行推送。");
                        batchCBO.copyFromOther(insertLoge);
                        WebUtil.setPersistence(true);
                        boService.persistenceBatch(batchCBO);
                    }
                    id = codeClassifyDOJson.getId();
                    name = codeClassifyDOJson.getName();
                    orderNum = codeClassifyDOJson.getOrderNum();
                    classifyoid_parent = codeClassifyDOJson.getParentCodeClassifyOid();
                }else {
                    id = codeClassifyDO.getId();
                    name = codeClassifyDO.getName();
                    orderNum = codeClassifyDO.getOrderNum();
                    classifyoid_parent = codeClassifyDO.getParentCodeClassifyOid();
                }

                //父级,idpath,namepath,分类数据视图中没有查询出路径，需要手动去查询
                CodeClassifyDO codeClassifyDO_parent = null;
                try {
                    codeClassifyDO_parent = codeClassifyDaoI.selectByPrimaryKey(classifyoid_parent);
                    xmlData.setParentId(codeClassifyDO_parent.getId());

                    //idpath,namepath

                    List<CodeClassifyDO> codeClassifyDOList = codeClassifyDaoI.listParentClassify(codeClassifyDO_parent.getOid());
                    for (int i=codeClassifyDOList.size()-1;i>=0;i--){
                        CodeClassifyDO codeClassifyDOi=codeClassifyDOList.get(i);
                        String idi = codeClassifyDOi.getId();
                        String namei = codeClassifyDOi.getName();
                        idpath = idpath==null?idi:idpath+"#"+idi;
                        namepath = namepath==null?namei:namepath+"#"+namei;
                    }
                }catch (Exception e){

                }

                idpath = idpath==null?id:idpath+"#"+id;
                namepath = namepath==null?name:namepath+"#"+name;

                //查询分类路径
                xmlData.setName(name);
                xmlData.setNamepath(namepath);
                xmlData.setIdpath(idpath);
                xmlData.setId(id);
                xmlData.setOrderNum(orderNum);

                List<XmlData> xmlDataList = new ArrayList<XmlData>();
                xmlDataList.add(xmlData);
                ret_xml = XmlUtil.writeSendXmlData_classify(xmlDataList);//xml格式数据
            }else {
                Map<String, String> data = null;
                try {
                    //表示是主数据
                    CodeClassifyTemplateVO codeClassifyTemplateVO = mdmEngineServiceI.getUsedTemplateByClassifyOid(classifyoid);
                    BaseResult<Map<String, String>> baseResult = mdmEngineServiceI.getDataByOid(btmoid, codeClassifyTemplateVO.getOid());

                    if (baseResult == null) {
                        JSONObject josni = redisService.getCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE + btmoid);
                        data = (Map) josni;
                    } else {
                        data = baseResult.getObj();
                    }
                }catch (Throwable e){
                    BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"未查询到相应数据！");
                    batchCBO.copyFromOther(failCbo);
                    continue;
                }

                //处理计量单位等转换
//                data = tran(data);

                //如果是集成erp部门数据集成，parentcode=null建立一级部门,无人机比较只有部门，没有科室,所以系统的科室其实就是他们的部门
                if("organization".equals(btmid.toLowerCase())){
                    String materialclassify = data.get("materialclassify");
                    if("科室".equals(materialclassify)){
                        data.put("parentcode","");
                    }
                }
                //数据转换d
                String tran_xml = null;
                try {
                    //D:\MDM_important\PLT-2022\web\tranTemp\+系统名称,会去找这个文件读取数据转换信息
                    tran_xml = FileUtils.readFileToString(new File(tranTemp+File.separator+systemcode+".xml"),"utf-8");
                }catch (IOException e){
                    e.printStackTrace();
                }
                if(StringUtils.isNotEmpty(tran_xml)){
                    //通过tran_xml对data数据转换
                    Map<String,Object> tran_map = null;
                    try {
                        tran_map = XmlUtil.readTranXml(tran_xml,btmid);
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                    if(tran_map!=null){//读取到这个btmid设置的转换关系了才做处理
                        for (String key:tran_map.keySet()){//key=materialtype
                            Object data_pro_mapo = tran_map.get(key);//data_pro_map
                            if(data_pro_mapo!=null){//这个值设置转换了才处理
                                Map<String,String> data_pro_map = (Map<String,String>)data_pro_mapo;
                                String mdm_value = data.get(key);
                                String system_value = data_pro_map.get(mdm_value);
                                if(StringUtils.isNotEmpty(mdm_value)){
                                    data.put(key,system_value);
                                }
                            }
                        }
                    }
                }

                String unique = null;
                List<Pro> pros = new ArrayList<Pro>();
                String codeclassifyoid = null;
                for (String key:data.keySet()){
                    Pro pro = new Pro();
                    pro.setKey(key);
                    pro.setMean("");
                    pro.setValue(data.getOrDefault(key,""));
                    pros.add(pro);
                    if(tuhao.equals(key)){
                        unique = data.getOrDefault(key,"");
                    }
                    if("oid".equals(key)){
                        codeclassifyoid = data.getOrDefault(key,"");
                    }
                }
                xmlData.setNum(data.getOrDefault("id",""));
                xmlData.setPros(pros);
                xmlData.setUnique(unique);

                //查询分类路径,主数据在视图中已经查询出了路径，只不过是,间隔的
                namepath = classifyname.replaceAll(",","#");
                idpath = classifyid.replaceAll(",","#");

                xmlData.setNamepath(namepath);
                xmlData.setIdpath(idpath);

                List<XmlData> xmlDataList = new ArrayList<XmlData>();
                xmlDataList.add(xmlData);
                ret_xml = XmlUtil.writeSendXmlData(xmlDataList);//xml格式数据
            }

            //切换xml/json
            String sendString = null;
            String backString = null;
            if(paramType.equals(MdmDuckingConstant.DATATYPE_JSON)){
                sendString = XML.toJSONObject(ret_xml).toString();
            }else {
                sendString = ret_xml;
            }
            logger.info("系统："+systemcode);
            logger.info("接口地址:"+url);
            logger.info("接口函数:"+interfaceFunction);
            logger.info("接口传递参数:"+sendString);
            //推送数据
            try {
                if (type.equals(MdmDuckingConstant.URLTYPE_GET)) {//GET请求
                    String sendurl = url + "?" + MdmDuckingConstant.PARAM_XMLDATA + "=" + sendString;
                    //拼接param
                    for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
                        sendurl = sendurl + "&" + sysIntParamDO.getParamkey() + "=" + sysIntParamDO.getParamvalue();
                    }
                    paramString=sendurl;
                    backString = HttpUtils.get(sendurl);
                } else if (type.equals(MdmDuckingConstant.URLTYPE_POST)) {//POST请求
                    MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
                    for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
                        params.add(sysIntParamDO.getParamkey(), sysIntParamDO.getParamvalue());
                    }
                    paramString=params.toString();
                    MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
                    for (SysIntHeaderDO sysIntHeaderDO : sysIntHeaderDOList) {
                        headers.add(sysIntHeaderDO.getHeaderkey(), sysIntHeaderDO.getHeaderalue());
                    }
                    backString = HttpUtils.post(url, params, headers);
                } else if (type.equals(MdmDuckingConstant.URLTYPE_WEBSERVICE)) {//webserver请求
                    MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
                    for (SysIntParamDO sysIntParamDO : sysIntParamDOList) {
                        params.add(sysIntParamDO.getParamkey(), sysIntParamDO.getParamvalue());
                    }
                    paramString=sendString;
                    MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
                    for (SysIntHeaderDO sysIntHeaderDO : sysIntHeaderDOList) {
                        headers.add(sysIntHeaderDO.getHeaderkey(), sysIntHeaderDO.getHeaderalue());
                    }
                    backString = WsErpClientUtil.sendMsg(url, namespace, soapaction,interfaceFunction,targName, paramString, 10000);
                } else {//corba接口

                }
                paramString=sendString;
            }catch (Exception e){
                e.printStackTrace();
                BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"推送数据失败！");
                batchCBO.copyFromOther(failCbo);
            }
            logger.info("接口返回参数:"+backString);
            //解析返还参数
            try {
                BackXml backXml = null;
                if(returnType.equals(MdmDuckingConstant.DATATYPE_JSON)){
                    backXml = XmlUtil.readSendJsonData(backString);//目前只读取主数据json返回信息
                }else {
                    if(MdmDuckingConstant.DOCKING_DEFAULT_CLASSIFY.equals(btmid)){
                        backXml = XmlUtil.readSendXmlData_classify(backString);//分类xml返回信息
                    }else {
                        backXml = XmlUtil.readSendXmlData(backString);//主数据xml返回信息
                    }
                }
                List<XmlData> datas = backXml.getDatas();
                boolean isSend = false;
                for (XmlData xmlDatai:datas){
                    String xml_datacode = xmlDatai.getState();
                    String xml_datamsg = xmlDatai.getMsg();
                    if(MdmDuckingConstant.XML_DATACODE_200.equals(xml_datacode)){
                        BatchCBO insertLoge = taskSuccess(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
                        batchCBO.copyFromOther(insertLoge);
                        isSend = true;
                    }else if(MdmDuckingConstant.XML_DATACODE_500.equals(xml_datacode)){
                        BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
                        batchCBO.copyFromOther(failCbo);
                    }else if("true".equals(xml_datacode.toLowerCase())){
                        BatchCBO insertLoge = taskSuccess(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
                        batchCBO.copyFromOther(insertLoge);
                        isSend = true;
                    }else if("false".equals(xml_datacode)){
                        BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,xml_datamsg);
                        batchCBO.copyFromOther(failCbo);
                    }else{
                        BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"返还xml格式不正确，缺少code!");
                        batchCBO.copyFromOther(failCbo);
                    }
                }

                //全都接收成功的情况下,修改dockingtask sendflag为已发送
                if(isSend) {
                    dockingTaskDO.setSendflag(MdmDuckingConstant.SEND_FLAG_TRUE);
                    BatchCBO updateTask = dockingTaskDaoI.updateByPrimaryKey(dockingTaskDO);
                    batchCBO.copyFromOther(updateTask);
                }

            }catch (Exception e){
                e.printStackTrace();
                BatchCBO failCbo = taskFail(systemcode,systemname,systemoid,classifyoid,classifyid,classifyname,dataid,uniquecode,paramString,url,"解析返还数据失败！");
                batchCBO.copyFromOther(failCbo);
            }

            //每一个task一个事物
            WebUtil.setPersistence(true);
            boService.persistenceBatch(batchCBO);

        }
    }

    public static Map<String,String> tranMap = new HashMap<String,String>();
    public Map<String,String> tran(Map<String,String> data){
        if(tranMap.isEmpty()){
//            tranMap.put("jiliangdw","jiliangdwname");
        }

        for (String key:tranMap.keySet()){
            String tran_key = tranMap.get(key);
            String tran_key_value = data.get(tran_key);
            if(StringUtils.isNotEmpty(tran_key_value)){
                data.put(key,tran_key_value);
            }
        }
        data.put("shifoupihaoguanli","0");
        return data;
    }

    /**
     * 定时任务推送
     */
    @Override
    public void DockingScheduing(){
        //data 2 task
        insertCache2();

        //推送数据
        sendData3();
    }

    /**
     * 数据删除的时候，缓存到redis
     * @param oid
     */
    @Override
    public void cacheDeleteData(String oid,Object obj){
        logger.info("删除数据插入redis,key: "+ MdmDuckingConstant.DOCKING_CACHE2_DELETE+",oid: "+oid+",obj: "+obj);
        redisService.setCacheObject(MdmDuckingConstant.DOCKING_CACHE2_DELETE + oid, obj);
    }

    @Override
    public DataGrid<DockingDataDO> gridData(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException {
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }
        pageHelper.addDefaultDesc("createTime");
        pageHelper.addDefaultAsc("sendflag");
        List<DockingDataDO> doList = dockingDataDaoI.selectByCondition(conditionMap,pageHelper);

        DataGrid<DockingDataDO> dataGrid=new DataGrid<DockingDataDO>();
        if (!CollectionUtils.isEmpty(doList)) {
            dataGrid.setData(doList);
            dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingDataDaoI.countByCondition(conditionMap))));
        }
        return dataGrid;
    }

    @Override
    public DataGrid<DockingTaskDO> gridTask(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException{
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }
        pageHelper.addDefaultDesc("createTime");
        pageHelper.addDefaultAsc("sendflag");
        List<DockingTaskDO> doList = dockingTaskDaoI.selectByCondition(conditionMap,pageHelper);

        DataGrid<DockingTaskDO> dataGrid=new DataGrid<DockingTaskDO>();
        if (!CollectionUtils.isEmpty(doList)) {
            dataGrid.setData(doList);
            dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingTaskDaoI.countByCondition(conditionMap))));
        }
        return dataGrid;
    }

    @Override
    public DataGrid<DockingLogeDO> gridLoge(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException{
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }
        pageHelper.addDefaultDesc("createTime");
        List<DockingLogeDO> doList = dockingLogeDaoI.selectByCondition(conditionMap,pageHelper);

        DataGrid<DockingLogeDO> dataGrid=new DataGrid<DockingLogeDO>();
        if (!CollectionUtils.isEmpty(doList)) {
            dataGrid.setData(doList);
            dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(dockingLogeDaoI.countByCondition(conditionMap))));
        }
        return dataGrid;
    }

    @Override
    public DataGrid<SysIntHeaderDO> gridHeader(Map<String, String> conditionMap, PageHelper pageHelper) throws VciBaseException{
        if (pageHelper == null) {
            pageHelper = new PageHelper(-1);
        }
        pageHelper.addDefaultDesc("createTime");
        List<SysIntHeaderDO> doList = sysIntHeaderDaoI.selectByCondition(conditionMap,pageHelper);

        DataGrid<SysIntHeaderDO> dataGrid=new DataGrid<SysIntHeaderDO>();
        if (!CollectionUtils.isEmpty(doList)) {
            dataGrid.setData(doList);
            dataGrid.setTotal(VciBaseUtil.getInt(String.valueOf(sysIntHeaderDaoI.countByCondition(conditionMap))));
        }
        return dataGrid;
    }
    /**
     * 推送成功,插入dockingtask，同时记录loge
     * @param systemcode
     * @param systemname
     * @param systemoid
     * @param paramString
     * @param url
     */
    public BatchCBO taskSuccess(String systemcode,String systemname,String systemoid,String classifyoid,String classifyid,String classifyname,String id,String uniquecode,String paramString,String url,String msg){
        String oid=redisService.getUUIDEveryDay();
        DockingLogeDO dockingLogeDO = new DockingLogeDO();
        dockingLogeDO.setOid(oid);
        dockingLogeDO.setSystemcode(systemcode);
        dockingLogeDO.setSystemname(systemname);
        dockingLogeDO.setSystemoid(systemoid);
        dockingLogeDO.setClassifyoid(classifyoid);
        dockingLogeDO.setClassifyid(classifyid);
        dockingLogeDO.setClassifyname(classifyname);
        dockingLogeDO.setId(id);
        dockingLogeDO.setUniquecode(uniquecode);
       /** if(paramString.length()>100){
            paramString = paramString.substring(0,100);
        }***/
        dockingLogeDO.setParamstring(paramString);
        dockingLogeDO.setType(MdmDuckingConstant.DATA_LOGE_OUT);

//        dockingLogeDO.setReturnstring(retString);
        dockingLogeDO.setMsg(msg);
        dockingLogeDO.setInterfacestatus(MdmDuckingConstant.INTERFACE_STATUS_TRUE);
        BatchCBO insert = dockingLogeDaoI.insert(dockingLogeDO);
        logger.info("集成推送数据成功,systemcode:"+systemcode+",systemname:"+systemcode+",url:"+url+",param:"+paramString);
        return insert;
    }

    /**
     * 推送失败,插入dockingtask，同时记录loge
     * @param systemcode
     * @param systemname
     * @param systemoid
     * @param paramString
     * @param url
     */
    public BatchCBO taskFail(String systemcode,String systemname,String systemoid,String classifyoid,String classifyid,String classifyname,String id,String uniquecode,String paramString,String url,String msg){
        String oid=redisService.getUUIDEveryDay();
        DockingLogeDO dockingLogeDO = new DockingLogeDO();
        dockingLogeDO.setOid(oid);
        dockingLogeDO.setSystemcode(systemcode);
        dockingLogeDO.setSystemname(systemname);
        dockingLogeDO.setSystemoid(systemoid);
        dockingLogeDO.setClassifyoid(classifyoid);
        dockingLogeDO.setClassifyid(classifyid);
        dockingLogeDO.setClassifyname(classifyname);
        dockingLogeDO.setId(id);
        dockingLogeDO.setUniquecode(uniquecode);
       /** if(StringUtils.isNotEmpty(paramString)&&paramString.length()>100){
            paramString = paramString.substring(0,100);
        }***/
        dockingLogeDO.setParamstring(paramString);
        dockingLogeDO.setType(MdmDuckingConstant.DATA_LOGE_OUT);

        dockingLogeDO.setMsg(msg);
        dockingLogeDO.setInterfacestatus(MdmDuckingConstant.INTERFACE_STATUS_FALSE);
        BatchCBO insert = dockingLogeDaoI.insert(dockingLogeDO);

        logger.error("集成推送数据失败,systemcode:"+systemcode+",systemname:"+systemcode+",url:"+url+",param:"+paramString+",e:"+msg);
        return insert;
    }
    public void initSysadmin(){
        SessionInfo sessionInfo = new SessionInfo();
        sessionInfo.setUserId("sysAdmin");
        sessionInfo.setUserName("系统管理员");
        sessionInfo.setIp(WebUtil.getLocalIp());
        sessionInfo.setUserOid("193C026F-7DB8-27B4-F383-4E8BE083FB07");
        sessionInfo.setUserSecret(UserSecretEnum.PRIVACY.getValue()+"");
        WebUtil.setSessionInfo(sessionInfo);
    }

    /**
     * dockingdata查询需要推送的数据
     * @return
     */
    public List<Map> getDockingDatas(){
        String sql = "select oid,id,classifyoid,btmid,btmoid,sendtype,classifyid,classifyname from PLATFORMBTM_codedockingDATA where sendflag = 'false'";
        List<Map> datas = boService.queryBySqlForMap(sql,null);
        return datas;
    }

    /**
     * dockingdata删除
     * @return
     */
    public boolean delteDockingData(String oid){
        boolean u = false;
        String sql = "delete from PLATFORMBTM_codedockingDATA where oid = '"+oid+"'";
        try {
            u=platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        }catch (Exception e){

        }
        return u;
    }

    /**
     * 查询图号
     * @return
     */
    public String getTuhao(String oid){
        String tuhao = "";
        String sql = "select tuhao from PLATFORMBTM_wupin where oid = '"+oid+"'";
        List<Map> datas = boService.queryBySqlForMap(sql,null);
        if(datas!=null&&datas.size()!=0){
            tuhao = datas.get(0).getOrDefault("tuhao","").toString();
        }
        return tuhao;
    }

    @Autowired
    private PlatformClientUtil platformClientUtil;
    /**
     * dockingdata根据oid修改sendflag
     * @param oid
     * @param sendflag
     * @return
     */
    public boolean updateDockingDatasSendFlag(String oid,String sendflag){
        boolean u=false;
        String sql = "update PLATFORMBTM_codedockingdata set sendFlag = '"+sendflag+"' where oid='"+oid+"'";
        try {
            u=platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        }catch (Exception e){

        }
        return u;
    }

    public boolean updateDockingDatasUniqueCode(String oid,String uniquecode){
        boolean u=false;
        String sql = "update PLATFORMBTM_codedockingdata set uniquecode = '"+uniquecode+"' where oid='"+oid+"'";
        try {
            u=platformClientUtil.getBOFactoryService().executeUpdateSql(sql);
        }catch (Exception e){

        }
        return u;
    }


}