package org.springblade.code.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.vci.mdm.constant.MdmDuckingConstant.*;

public class XmlUtil {
    /*
    第一版本
     */
    public static Map<String,Object> readPreXml_bak(String xmlData) throws Exception{

        Map<String,Object> datasMap = new HashMap<String,Object>();

        Document document = DocumentHelper.parseText(xmlData);
        Element datas_element = document.getRootElement();
        Attribute datas_systemid_attr = datas_element.attribute(XML_SYSTEMID);
        String systemid = datas_systemid_attr==null?"":datas_systemid_attr.getValue();//systemid

        List<Element> data_elements = datas_element.elements(XML_DATA);
        List<Map<String,Object>> dataMapList = new ArrayList<Map<String,Object>>();
        for (Element data_element:data_elements){
            Map<String,Object> dataMap = new HashMap<String,Object>();

            Attribute data_unique_attr = data_element.attribute(XML_UNIQUE);
            String unique = data_unique_attr==null?"":data_unique_attr.getValue();//unique

            Attribute data_type_attr = data_element.attribute(XML_TYPE);
            String type = data_type_attr==null?"":data_type_attr.getValue();//type

            Element pro_elements = data_element.element(XML_PROS);
            List<Element> attrs_elements = pro_elements.elements(XML_ATTR);

            List<Map<String,String>> attrList = new ArrayList<Map<String,String>>();
            for (Element attr_element:attrs_elements){
                Map<String,String> attrMap = new HashMap<String,String>();

                Attribute attr_key_attr = attr_element.attribute(XML_KEY);
                String attr_key = attr_key_attr==null?"":attr_key_attr.getValue();//key

                Attribute attr_mean_attr = attr_element.attribute(XML_MEAN);
                String attr_mean = attr_mean_attr==null?"":attr_mean_attr.getValue();//mean

                String attr_text = attr_element.getText();

                attrMap.put(XML_KEY,attr_key);
                attrMap.put(XML_MEAN,attr_mean);
                attrMap.put(XML_TEXT,attr_text);
                attrList.add(attrMap);
            }
            dataMap.put(XML_UNIQUE,unique);
            dataMap.put(XML_TYPE,type);
            dataMap.put(XML_ATTR,attrList);

            dataMapList.add(dataMap);

            datasMap.put(XML_SYSTEMID,systemid);
            datasMap.put(XML_DATAS,dataMapList);
        }
        return datasMap;
    }

    public static String writePreBackXmlData_bak(String code,String msg,List<XmlData> xmlDataList){
        String xmlString = null;
        try {
            Document document = DocumentHelper.createDocument();
            document.setXMLEncoding("UTF-8");
            Element root = document.addElement(XML_DATAS);
            root.addAttribute(XML_CODE, code);
            root.addAttribute(XML_MSG, msg);
            if(xmlDataList!=null) {
                for (XmlData xmlData : xmlDataList) {
                    if(xmlData==null){
                        continue;
                    }
                    Element data_element = root.addElement(XML_DATA);
                    data_element.addAttribute(XML_UNIQUE, xmlData.getUnique());
                    data_element.addAttribute(XML_STATE, xmlData.getState());
                    data_element.addAttribute(XML_MSG, xmlData.getMsg());
                    data_element.addAttribute(XML_NUM, xmlData.getNum());
                }
            }
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(format);
            writer.write(document);
            xmlString=document.asXML();
        } catch (Exception e) {
            // TODO: handle exception
        }
        return xmlString;
    }

    /*
    根据部长已经修改的第一版
    <object>
        <systemid>MPM</systemid>
        <datas>
            <data>
                <unique>oa0001</unique>
                <type>wupin</type>
                <pros>
                    <pro>
                        <key>code01</key>
                        <mean>所属结构</mean>
                        <value>温度调节器1</value>
                    </pro>
                    <pro>
                        <key>code02</key>
                        <mean>主要功能</mean>
                        <value>导电连接1</value>
                    </pro>
                </pros>
            </data>
            <data>
                <unique>oa0002</unique>
                <type>wupin</type>
                <pros>
                    <pro>
                        <key>code01</key>
                        <mean>所属结构</mean>
                        <value>温度调节器2</value>
                    </pro>
                    <pro>
                        <key>code02</key>
                        <mean>主要功能</mean>
                        <value>导电连接2</value>
                    </pro>
                </pros>
            </data>
        </datas>
    </object>
     */
    public static Map<String,Object> readPreXml1(String xmlData) throws Exception{

        Map<String,Object> datasMap = new HashMap<String,Object>();

        Document document = DocumentHelper.parseText(xmlData);
        Element object_element = document.getRootElement();
        Element system_element = object_element.element(XML_SYSTEMID);
        String systemid = system_element.getText();
        Element datas_element = object_element.element(XML_DATAS);
        List<Element> data_elements = datas_element.elements(XML_DATA);
        List<Map<String,Object>> datasList = new ArrayList<Map<String,Object>>();
        for (Element data_element:data_elements){
            Map<String,Object> dataMap = new HashMap<String,Object>();

            Attribute data_unique_attr = data_element.attribute(XML_UNIQUE);
            String unique = data_unique_attr==null?"":data_unique_attr.getValue();//unique

            Attribute data_type_attr = data_element.attribute(XML_TYPE);
            String type = data_type_attr==null?"":data_type_attr.getValue();//type

            Element pros_elements = data_element.element(XML_PROS);
            List<Element> pro_elements = pros_elements.elements(XML_PRO);

            List<Map<String,String>> proList = new ArrayList<Map<String,String>>();
            for (Element pro_element:pro_elements){
                Map<String,String> proMap = new HashMap<String,String>();

                Element pro_key_element = pro_element.element(XML_KEY);
                String pro_key = pro_key_element==null?"":pro_key_element.getText();//key

                Element pro_mean_element = pro_element.element(XML_MEAN);
                String pro_mean = pro_mean_element==null?"":pro_mean_element.getText();//mean

                String pro_text = pro_element.getText();

                proMap.put(XML_KEY,pro_key);
                proMap.put(XML_MEAN,pro_mean);
                proMap.put(XML_TEXT,pro_text);
                proList.add(proMap);
            }
            dataMap.put(XML_UNIQUE,unique);
            dataMap.put(XML_TYPE,type);
            dataMap.put(XML_PROS,proList);

            datasList.add(dataMap);

            datasMap.put(XML_SYSTEMID,systemid);
            datasMap.put(XML_DATAS,datasList);
        }
        return datasMap;
    }

    /*
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <msg>处理成功</msg>
        <code>200</code>
        <datas>
            <data>
                <unique>oa0001</unique>
                <datacode>200</datacode>
                <datamsg>根据图号查询编码成功！</datamsg>
                <num>OA-0002-01</num>
            </data>
            <data>
                <unique>oa0002</unique>
                <datacode>400</datacode>
                <datamsg>接收数据成功！</datamsg>
                <num/>
            </data>
            <data>
                <unique>oa0003</unique>
                <datacode>500</datacode>
                <datamsg>接收数据失败，参数缺少unique！</datamsg>
                <num/>
            </data>
        </datas>
    </object>
     */
    public static String writePreBackXmlData1(String code,String msg,List<XmlData> xmlDataList){
        String xmlString = null;
        try {
            Document document = DocumentHelper.createDocument();
            document.setXMLEncoding("UTF-8");
            Element object_element = document.addElement(XML_OBJECT);

            Element code_element = object_element.addElement(XML_CODE);
            code_element.setText(code);

            Element msg_element = object_element.addElement(XML_MSG);
            msg_element.setText(msg);

            if(xmlDataList!=null) {
                for (XmlData xmlData : xmlDataList) {
                    if(xmlData==null){
                        continue;
                    }
                    Element data_element = object_element.addElement(XML_DATA);

                    Element unique_element = data_element.addElement(XML_UNIQUE);
                    unique_element.setText(xmlData.getUnique());

                    Element datacode_element = data_element.addElement(XML_DATACODE);
                    datacode_element.setText(xmlData.getState());

                    Element datacmsg_element = data_element.addElement(XML_DATAMSG);
                    datacmsg_element.setText(xmlData.getMsg());

                    Element num_element = data_element.addElement(XML_NUM);
                    num_element.setText(xmlData.getNum());
                }
            }
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(format);
            writer.write(document);
            xmlString=document.asXML();
        } catch (Exception e) {
            // TODO: handle exception
        }
        return xmlString;
    }

    /*
    部长亲自动手修改的版本
    <?xml version="1.0" encoding="UTF-8"?>
    <object systemid="MPM">
        <datas>
            <data unique="oa0001" type="wupin">
                <props>
                    <prop key="code01" mean="所属结构" value="温度调节器1" />
                    <prop key="code02" mean="主要功能" value="导电连接1" />
                </props>
            </data>
            <data unique="oa0002" type="wupin">
                <props>
                    <prop key="code01" mean="所属结构" value="温度调节器2" />
                    <prop key="code02" mean="主要功能" value="导电连接2" />
                </props>
            </data>
        </datas>
    </object>
     */
    public static Map<String,Object> readPreXmlData(String xmlData) throws Exception{

        Map<String,Object> datasMap = new HashMap<String,Object>();

        Document document = DocumentHelper.parseText(xmlData);
        Element object_element = document.getRootElement();

        Attribute systemid_attr = object_element.attribute(XML_SYSTEMID);
        String systemid = systemid_attr.getValue();

        Element datas_element = object_element.element(XML_DATAS);
        List<Element> data_elements = datas_element.elements(XML_DATA);
        List<Map<String,Object>> datasList = new ArrayList<Map<String,Object>>();
        for (Element data_element:data_elements){
            Map<String,Object> dataMap = new HashMap<String,Object>();

            Attribute data_unique_attr = data_element.attribute(XML_UNIQUE);
            String unique = data_unique_attr==null?"":data_unique_attr.getValue();//unique

            Attribute data_type_attr = data_element.attribute(XML_TYPE);
            String type = data_type_attr==null?"":data_type_attr.getValue();//type

            Element pros_elements = data_element.element(XML_PROS);
            List<Element> pro_elements = pros_elements.elements(XML_PRO);

            List<Map<String,String>> proList = new ArrayList<Map<String,String>>();
            for (Element pro_element:pro_elements){
                Map<String,String> proMap = new HashMap<String,String>();

                Attribute pro_key_attr = pro_element.attribute(XML_KEY);
                String pro_key = pro_key_attr==null?"":pro_key_attr.getValue();//key

                pro_key = pro_key.toLowerCase();//全都转换为小写

                Attribute pro_mean_attr = pro_element.attribute(XML_MEAN);
                String pro_mean = pro_mean_attr==null?"":pro_mean_attr.getValue();//mean

                Attribute pro_value_attr = pro_element.attribute(XML_VALUE);
                String pro_value = pro_value_attr==null?"":pro_value_attr.getValue();//mean

                proMap.put(XML_KEY,pro_key);
                proMap.put(XML_MEAN,pro_mean);
                proMap.put(XML_TEXT,pro_value);
                proList.add(proMap);
            }
            dataMap.put(XML_UNIQUE,unique);
            dataMap.put(XML_TYPE,type);
            dataMap.put(XML_PROS,proList);

            datasList.add(dataMap);

            datasMap.put(XML_SYSTEMID,systemid);
            datasMap.put(XML_DATAS,datasList);
        }
        return datasMap;
    }

    /*
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <msg>处理成功</msg>
        <code>200</code>
        <datas>
            <data unique="oa0001" state="200" num="OA-0002-01">
                <msg>根据图号查询编码成功！</msg>
            </data>
            <data unique="oa0002" state="400" num="">
                <msg>接收数据成功！</msg>
            </data>
        </datas>
    </object>
     */
    public static String writePreBackXmlData(String code,String msg,List<XmlData> xmlDataList){
        String xmlString = null;
        try {
            Document document = DocumentHelper.createDocument();
            document.setXMLEncoding("UTF-8");
            Element object_element = document.addElement(XML_OBJECT);

            Element code_element = object_element.addElement(XML_CODE);
            code_element.setText(code);

            Element msg_element = object_element.addElement(XML_MSG);
            msg_element.setText(msg);

            Element datas_element = object_element.addElement(XML_DATAS);

            if(xmlDataList!=null) {
                for (XmlData xmlData : xmlDataList) {
                    if(xmlData==null){
                        continue;
                    }
                    Element data_element = datas_element.addElement(XML_DATA);

                    data_element.addAttribute(XML_UNIQUE,xmlData.getUnique());
                    data_element.addAttribute(XML_STATE,xmlData.getState());
                    data_element.addAttribute(XML_NUM,xmlData.getNum());

                    Element datamsg_element = data_element.addElement(XML_MSG);
                    datamsg_element.setText(xmlData.getMsg());
                }
            }
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(format);
            writer.write(document);
            xmlString=document.asXML();
        } catch (Exception e) {
            // TODO: handle exception
        }
        return xmlString;
    }

    /*
    主数据推送的xmlData格式
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <datas>
            <data unique="oa0002" type="wupin" state="3" num="01020000003">
                <namepath>物品#成品及附件</namepath>
                <idpath>wuping#cpjfj</idpath>
                <props>
                    <prop key="code01" mean="所属结构" value="温度调节器2" />
                    <prop key="code02" mean="主要功能" value="导线连接2" />
                </props>
            </data>
        </datas>
    </object>
     */
    public static String writeSendXmlData(List<XmlData> xmlDataList) {
        String xmlString = null;
        try {
            Document document = DocumentHelper.createDocument();
            document.setXMLEncoding("UTF-8");
            Element object_element = document.addElement(XML_OBJECT);

            Element datas_element = object_element.addElement(XML_DATAS);

            if (xmlDataList != null) {
                for (XmlData xmlData : xmlDataList) {
                    if (xmlData == null) {
                        continue;
                    }
                    Element data_element = datas_element.addElement(XML_DATA);
                    data_element.addAttribute(XML_UNIQUE, xmlData.getUnique());
                    data_element.addAttribute(XML_TYPE, xmlData.getType());
                    data_element.addAttribute(XML_STATE, xmlData.getSendtype());

                    Element pros_element = data_element.addElement(XML_PROS);
                    List<Pro> pros = xmlData.getPros();
                    String lcstatue = null;
                    String id = null;
                    for (Pro pro : pros) {
                        if("lcstatus".equals(pro.getKey())){
                            lcstatue = pro.getValue();
                        }
                        if("id".equals(pro.getKey())){
                            id = pro.getValue();
                        }
                        Element pro_element = pros_element.addElement(XML_PRO);
                        pro_element.addAttribute(XML_KEY, pro.getKey());
                        pro_element.addAttribute(XML_VALUE, pro.getValue());
                        pro_element.addAttribute(XML_MEAN, pro.getKey());
                    }
                    if(StringUtils.isNotEmpty(lcstatue)){
                        data_element.addAttribute(XML_STATE, lcstatue);
                    }
                    if(StringUtils.isNotEmpty(id)){
                        data_element.addAttribute(XML_NUM, id);
                    }

                    Element pro_namepath_element = data_element.addElement(XML_NAMEPATH);
                    pro_namepath_element.setText(xmlData.getNamepath());

                    Element pro_idpath_element = data_element.addElement(XML_IDPATH);
                    pro_idpath_element.setText(xmlData.getIdpath());
                }
            }
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(format);
            writer.write(document);
            xmlString = document.asXML();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return xmlString;
    }

    /*
    分类数据推送的xmlData格式
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <datas>
            <data>
                <id>shoutao</id>
                <idpath>wuping#shoutao</idpath>
                <name>手套</name>
                <namepath>物品#手套</namepath>
                <orderNum>2</orderNum>
                <parentId>wuping</parentId>
            </data>
        </datas>
     </object>
     */
    public static String writeSendXmlData_classify(List<XmlData> xmlDataList) {
        String xmlString = null;
        try {
            Document document = DocumentHelper.createDocument();
            document.setXMLEncoding("UTF-8");
            Element object_element = document.addElement(XML_OBJECT);

            Element datas_element = object_element.addElement(XML_DATAS);

            if (xmlDataList != null) {
                for (XmlData xmlData : xmlDataList) {
                    if (xmlData == null) {
                        continue;
                    }
                    Element data_element = datas_element.addElement(XML_DATA);

                    Element pro_name_element = data_element.addElement(XML_NAME);
                    pro_name_element.setText(xmlData.getName());

                    Element pro_namepath_element = data_element.addElement(XML_NAMEPATH);
                    pro_namepath_element.setText(xmlData.getNamepath());

                    Element pro_id_element = data_element.addElement(XML_ID);
                    pro_id_element.setText(xmlData.getId());

                    Element pro_idpath_element = data_element.addElement(XML_IDPATH);
                    pro_idpath_element.setText(xmlData.getIdpath());

                    Element pro_ordernum_element = data_element.addElement(XML_ORDERNUM);
                    pro_ordernum_element.setText(xmlData.getOrderNum()+"");

                    Element pro_parentid_element = data_element.addElement(XML_PARENTID);
                    pro_parentid_element.setText(xmlData.getParentId()==null?"":xmlData.getParentId());

                    Element pro_state_element = data_element.addElement(XML_STATE);
                    pro_state_element.setText(xmlData.getSendtype());
                }
            }
            OutputFormat format = OutputFormat.createPrettyPrint();
            XMLWriter writer = new XMLWriter(format);
            writer.write(document);
            xmlString = document.asXML();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return xmlString;
    }

    /*
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <msg>处理成功</msg>
        <code>200</code>
        <datas>
        <data unique="oa0001" state="200" num="01020000001">
            <msg>接收数据成功！</msg>
        </data>
        </datas>
    </object>
     */
    public static BackXml readSendXmlData(String xmlData) throws Exception{

        BackXml backXml = new BackXml();
        Document document = DocumentHelper.parseText(xmlData);
        Element object_element = document.getRootElement();

        Element code_element = object_element.element(XML_CODE);
        String code = code_element.getText();

        Element msg_element = object_element.element(XML_MSG);
        String msg = msg_element.getText();

        Element datas_element = object_element.element(XML_DATAS);

        List<Element> data_elements = datas_element.elements(XML_DATA);
        List<XmlData> datasList = new ArrayList<XmlData>();
        for (Element data_element:data_elements){
            XmlData xmlData_return = new XmlData();

            Attribute data_unique_attr = data_element.attribute(XML_UNIQUE);
            String unique = data_unique_attr==null?"":data_unique_attr.getValue();//unique

            Attribute data_state_attr = data_element.attribute(XML_STATE);
            String state = data_state_attr==null?"":data_state_attr.getValue();//state

            Attribute data_num_attr = data_element.attribute(XML_NUM);
            String num = data_num_attr==null?"":data_num_attr.getValue();//num

            Element data_msg_elements = data_element.element(XML_MSG);
            String datamsg = data_msg_elements==null?"":data_msg_elements.getText();//msg

            xmlData_return.setUnique(unique);
            xmlData_return.setState(state);
            xmlData_return.setNum(num);
            xmlData_return.setMsg(datamsg);
            datasList.add(xmlData_return);
        }
        backXml.setState(code);
        backXml.setMsg(msg);
        backXml.setDatas(datasList);
        return backXml;
    }

    /*
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <msg>推送成功</msg>
        <code>200</code>
        <datas>
            <data>
                <idpath>wuping#shoutao</idpath>
                <state>true</state>
            </data>
            <data>
                <idpath>wuping#fanghufu</idpath>
                <state>false</state>
            </data>
        </datas>
    </object>
     */
    public static BackXml readSendXmlData_classify(String xmlData) throws Exception{

        BackXml backXml = new BackXml();
        Document document = DocumentHelper.parseText(xmlData);
        Element object_element = document.getRootElement();

        Element code_element = object_element.element(XML_CODE);
        String code = code_element.getText();

        Element msg_element = object_element.element(XML_MSG);
        String msg = msg_element.getText();

        Element datas_element = object_element.element(XML_DATAS);

        List<Element> data_elements = datas_element.elements(XML_DATA);
        List<XmlData> datasList = new ArrayList<XmlData>();
        for (Element data_element:data_elements){
            XmlData xmlData_return = new XmlData();

            Element data_idpath_elements = data_element.element(XML_IDPATH);
            String idpath = data_idpath_elements.getText();

            Element data_state_elements = data_element.element(XML_STATE);
            String state = data_state_elements.getText();

            Element xml_msg_elements = data_element.element(XML_MSG);
            String xml_msg = xml_msg_elements.getText();

            xmlData_return.setIdpath(idpath);
            xmlData_return.setMsg(xml_msg);
            xmlData_return.setState(state);

            datasList.add(xmlData_return);
        }
        backXml.setState(code);
        backXml.setMsg(msg);
        backXml.setDatas(datasList);
        return backXml;
    }

    /*
    <?xml version="1.0" encoding="UTF-8"?>
    <object>
        <msg>处理成功</msg>
        <code>200</code>
        <datas>
        <data unique="oa0001" state="200" num="01020000001">
            <msg>接收数据成功！</msg>
        </data>
        </datas>
    </object>
     */
    public static BackXml readSendJsonData(String jsonData) throws Exception{

        BackXml backXml = new BackXml();
        JSONObject json_root = JSONObject.parseObject(jsonData);
        String code = json_root.getString(XML_CODE);
        String msg = json_root.getString(XML_MSG);
        Object datas_obj = json_root.get(XML_DATAS);

        List<XmlData> datasList = new ArrayList<XmlData>();
        if(datas_obj!=null){
            JSONArray datas_arr = (JSONArray)datas_obj;
            for (Object data_obj:datas_arr){
                XmlData xmlData_return = new XmlData();

                JSONObject data_json = (JSONObject)data_obj;
                String unique = data_json.getString(XML_UNIQUE);
                String state = data_json.getString(XML_STATE);
                String num = data_json.getString(XML_NUM);
                String datamsg = data_json.getString(XML_MSG);

                xmlData_return.setUnique(unique);
                xmlData_return.setState(state);
                xmlData_return.setNum(num);
                xmlData_return.setMsg(datamsg);
                datasList.add(xmlData_return);
            }
        }

        backXml.setState(code);
        backXml.setMsg(msg);
        backXml.setDatas(datasList);
        return backXml;
    }

    //读取数据转换xml数据为map
    /*
<?xml version="1.0" encoding="UTF-8"?>
<object>
<datas>
<data type="wupin">
<props>
<prop key="materialtype">
<prop_tran mdmkey="1001" mdmvalue="材料" systemkey="" tranvalue=""/>
<prop_tran mdmkey="1002" mdmvalue="成品" systemkey="" tranvalue=""/>
<prop_tran mdmkey="1003" mdmvalue="机物料" systemkey="" tranvalue=""/>
<prop_tran mdmkey="1004" mdmvalue="综保" systemkey="" tranvalue=""/>
<prop_tran mdmkey="1005" mdmvalue="资产" systemkey="" tranvalue=""/>
</prop>
</props>
</data>
</datas>
</object>
     */
    public static Map<String,Object> readTranXml(String tran_xml,String btmid) throws Exception{
        Map<String,Object> retMap = new HashMap<String,Object>();
        if(StringUtils.isEmpty(btmid)){
            return retMap;
        }
        Document document = DocumentHelper.parseText(tran_xml);
        Element object_element = document.getRootElement();

        Element datas_element = object_element.element(XML_DATAS);

        List<Element> data_elements = datas_element.elements(XML_DATA);
        for (Element data_element:data_elements){

            Attribute data_type_attr = data_element.attribute(XML_TYPE);
            String data_type = data_type_attr==null?"":data_type_attr.getValue();
            if(!btmid.equals(data_type)){
                continue;
            }

            Element data_pros_elements = data_element.element(XML_PROS);
            List<Element> data_pro_elements = data_pros_elements.elements(XML_PRO);
            for (Element data_pro_element:data_pro_elements) {
                Map<String,String> data_pro_map = new HashMap<String,String>();
                Attribute xml_type_attr = data_pro_element.attribute(XML_KEY);//materialtype
                String xml_type = xml_type_attr==null?"":xml_type_attr.getValue();

                List<Element>prop_tran_elements = data_pro_element.elements(XML_PRO_TRAN);//prop_tran
                for (Element prop_tran_element:prop_tran_elements) {
                    Attribute mdm_key_attr = prop_tran_element.attribute(XML_MDMKEY);
                    String mdm_key = mdm_key_attr==null?"":mdm_key_attr.getValue();

                    Attribute mdm_value_attr = prop_tran_element.attribute(XML_MDMVALUE);
                    String mdm_value = mdm_value_attr==null?"":mdm_value_attr.getValue();

                    Attribute system_key_attr = prop_tran_element.attribute(XML_SYSTEMKEY);
                    String system_key = system_key_attr==null?"":system_key_attr.getValue();

                    Attribute system_value_attr = prop_tran_element.attribute(XML_SYSTEMVALUE);
                    String system_value = system_value_attr==null?"":system_value_attr.getValue();

//                  data_pro_map.put(XML_MDMKEY,mdm_key);
//                  data_pro_map.put(XML_MDMVALUE,mdm_value);
//                  data_pro_map.put(XML_SYSTEMKEY,system_key);
//                  data_pro_map.put(XML_SYSTEMVALUE,system_value);
                    data_pro_map.put(mdm_key,system_key);
                    data_pro_map.put(mdm_value,system_value);
                }
                retMap.put(xml_type,data_pro_map);
            }

        }
        return retMap;
    }
}