tengda/websrc/com/kingdee/eas/custom/webbeisen/test/BeiSenSysTest.java

package com.kingdee.eas.custom.webbeisen.test;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.kingdee.bos.BOSException;
import com.kingdee.bos.BOSObjectFactory;
import com.kingdee.bos.Context;
import com.kingdee.bos.bsf.service.app.IHRMsfService;
import com.kingdee.bos.dao.IObjectPK;
import com.kingdee.bos.metadata.entity.*;
import com.kingdee.bos.metadata.query.util.CompareType;
import com.kingdee.bos.util.BOSUuid;
import com.kingdee.eas.base.attachment.AttachmentFactory;
import com.kingdee.eas.base.attachment.AttachmentInfo;
import com.kingdee.eas.base.attachment.BoAttchAssoFactory;
import com.kingdee.eas.base.attachment.BoAttchAssoInfo;
import com.kingdee.eas.base.permission.UserFactory;
import com.kingdee.eas.base.permission.UserInfo;
import com.kingdee.eas.basedata.person.PersonInfo;
import com.kingdee.eas.common.EASBizException;
import com.kingdee.eas.custom.beisenconfig.*;
import com.kingdee.eas.custom.enumerations.ViewTypeEnum;
import com.kingdee.eas.custom.webbeisen.utils.Helper;
import com.kingdee.eas.framework.CoreBaseCollection;
import com.kingdee.eas.framework.CoreBaseInfo;
import com.kingdee.eas.framework.ICoreBase;
import com.kingdee.eas.hr.affair.EmpEnrollBizBillEntryCollection;
import com.kingdee.eas.hr.affair.EmpEnrollBizBillEntryInfo;
import com.kingdee.eas.hr.emp.PersonPhotoFactory;
import com.kingdee.eas.hr.emp.PersonPhotoInfo;
import com.kingdee.shr.attachment.AttachmentState;
import com.kingdee.shr.attachment.AttachmentTypeEnum;
import com.kingdee.shr.attachment.SHRAttachmentExtFactory;
import com.kingdee.shr.attachment.SHRAttachmentExtInfo;
import com.kingdee.shr.base.syssetting.MSFServiceFacadeFactory;
import com.kingdee.shr.base.syssetting.UIType;
import com.kingdee.shr.base.syssetting.UIViewFactory;
import com.kingdee.shr.base.syssetting.UIViewInfo;
import com.kingdee.shr.base.syssetting.app.util.XMLUtil;
import com.kingdee.shr.base.syssetting.exception.SHRWebException;
import com.kingdee.shr.base.syssetting.exception.ShrWebBizException;
import com.kingdee.shr.base.syssetting.ml.SHRWebResource;
import com.kingdee.shr.base.syssetting.util.MetaDataUtil;
import com.kingdee.shr.base.syssetting.util.SysSettingUIViewUtil;
import com.kingdee.shr.base.syssetting.web.dynamic.model.FieldInfo;
import com.kingdee.shr.base.syssetting.web.dynamic.view.converter.IUIViewConverter;
import com.kingdee.shr.base.syssetting.web.dynamic.view.converter.UIViewConverterFactory;
import com.kingdee.shr.ml.MLServiceFactory;
import com.kingdee.shr.ml.ResourceType;
import com.kingdee.util.LocaleUtils;
import com.kingdee.util.StringUtils;
import org.apache.log4j.Logger;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.output.XMLOutputter;
import org.jdom.xpath.XPath;
import org.json.JSONException;

import java.io.IOException;
import java.text.MessageFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class BeiSenSysTest implements IHRMsfService {
    Helper helper = null;
    Context context = null;
    private static Logger logger =
            Logger.getLogger("com.kingdee.eas.custom.beisen.synchronousorg.SynchronousEmpBillControllerBean");

    @Override
    public Object process(Context context, Map map) throws EASBizException, BOSException {
        String param = map.get("param") == null ? "" : map.get("param").toString();
        empBill(context,param,"i6MAAAABB+gL9cGD" );
        return null;
    }


    public void empBill(Context ctx, String param, String viewConfigId) throws BOSException {
        helper = new Helper(ctx);
        this.context = ctx;
        EntityViewInfo entityViewInfo = new EntityViewInfo();
        FilterInfo filterInfo = new FilterInfo();
        filterInfo.getFilterItems().add(new FilterItemInfo("isEnabled", true, CompareType.EQUALS));
        filterInfo.getFilterItems().add(new FilterItemInfo("id", viewConfigId, CompareType.EQUALS));
        entityViewInfo.setFilter(filterInfo);
        //获取北森视图配置信息
        BSViewConfigCollection bsViewConfigCollection = BSViewConfigFactory.getLocalInstance(ctx).getBSViewConfigCollection(entityViewInfo);
        if (bsViewConfigCollection.size() <= 0) {
            throw new RuntimeException("配置未启用或者不存在");
        }
        BSViewConfigInfo bsViewConfigInfo = bsViewConfigCollection.get(0);
        String osfParam = bsViewConfigInfo.getOsfParam();
        String osfSericeName = bsViewConfigInfo.getOsfSericeName();
        Map<String, Object> serviceParam = new HashMap<String,Object>();
        if (param!=null&&!param.equals("")){
            JSONObject jsonObject = JSONObject.parseObject(osfParam);
            jsonObject.put("staffId",param);
            osfParam= jsonObject.toJSONString();
        }
        serviceParam.put("param", osfParam);
        JSONArray beiSenData = null;
        try {
            SelectorItemCollection selectorItemCollection = new SelectorItemCollection();
            selectorItemCollection.add("*");
            selectorItemCollection.add("view.*");

            Object o = MSFServiceFacadeFactory.getLocalInstance(ctx).processService(osfSericeName, serviceParam);
            beiSenData = JSONArray.parseArray(o.toString());
            //查询头部视图配置 头部视图配置只能有一个
            EntityViewInfo entryHeadEntityViewInfo = new EntityViewInfo();
            FilterInfo entryHeadFilterInfo = new FilterInfo();
            entryHeadFilterInfo.getFilterItems().add(new FilterItemInfo("parent", bsViewConfigInfo.getId().toString(), CompareType.EQUALS));
            entryHeadFilterInfo.getFilterItems().add(new FilterItemInfo("boy", ViewTypeEnum.HEAD_VALUE, CompareType.EQUALS));
            entryHeadEntityViewInfo.setSelector(selectorItemCollection);
            entryHeadEntityViewInfo.setFilter(entryHeadFilterInfo);
            BSViewConfigEntryCollection headBsViewConfigEntryCollection = BSViewConfigEntryFactory
                    .getLocalInstance(ctx).getBSViewConfigEntryCollection(entryHeadEntityViewInfo);
            if (headBsViewConfigEntryCollection.size() != 1) {
                throw new RuntimeException("头部配置有且只能有一个");
            }
            BSViewConfigEntryInfo bsViewConfigEntryInfo = headBsViewConfigEntryCollection.get(0);
            UIViewInfo view = bsViewConfigEntryInfo.getView();
            String file = bsViewConfigEntryInfo.getFile();
            for (int i = 0; i < beiSenData.size(); i++) {
                JSONObject jsonObject1 = beiSenData.getJSONObject(i);
                JSONArray fileArray = jsonObject1.getJSONArray(file);
                boolean isCreateData = bsViewConfigEntryInfo.isIsCreateData();
                String headId = null;
                if (isCreateData){
                    headId = headProcessing(view, jsonObject1, fileArray, file);
                }else {
                    String headDataEntry = bsViewConfigEntryInfo.getHeadDataEntry();
                    String headWhere = bsViewConfigEntryInfo.getHeadWhere();
                    Class objectValueClass = MetaDataUtil.getObjectValueClass(headDataEntry);
                    // 创建对应的实体对象
                    CoreBaseInfo coreBaseInfo = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass, headDataEntry);
                    // 创建对应的业务对象
                    ICoreBase bosObject = (ICoreBase) (BOSObjectFactory.createBOSObject(context, coreBaseInfo.getBOSType()));
                    String string = jsonObject1.getJSONObject("staffInfos").getString("id");
                    CoreBaseCollection collection = bosObject.getCollection("where beisenId='" + string + "'");
                    if (collection.size()>0){
                        headId = collection.get(0).getId().toString();
                    }
                }

                if (headId == null){
                    continue;
                }

                EntityViewInfo entryBoyEntityViewInfo = new EntityViewInfo();
                FilterInfo entryBoyFilterInfo = new FilterInfo();
                entryBoyFilterInfo.getFilterItems().add(new FilterItemInfo("parent", bsViewConfigInfo.getId().toString(), CompareType.EQUALS));
                entryBoyFilterInfo.getFilterItems().add(new FilterItemInfo("boy", ViewTypeEnum.BOY_VALUE, CompareType.EQUALS));
                entryBoyEntityViewInfo.setSelector(selectorItemCollection);
                entryBoyEntityViewInfo.setFilter(entryBoyFilterInfo);
                BSViewConfigEntryCollection boyBsViewConfigEntryCollection = BSViewConfigEntryFactory
                        .getLocalInstance(ctx).getBSViewConfigEntryCollection(entryBoyEntityViewInfo);
                for (int j = 0; j < boyBsViewConfigEntryCollection.size(); j++) {
                    BSViewConfigEntryInfo boybsViewConfigEntryInfo = boyBsViewConfigEntryCollection.get(j);
                    UIViewInfo view1 = boybsViewConfigEntryInfo.getView();
                    String beiSenData1 = boybsViewConfigEntryInfo.getBeiSenData();
                    UIType type = view1.getType();
                    if(type.getValue().equals("list")){
                        boyProcessing(view1,headId,jsonObject1.getJSONArray(beiSenData1),null,"fileInfos",beiSenData1);
                    }else {
                        boyProcessing(view1,headId,jsonObject1.getJSONObject(beiSenData1),null,"fileInfos",beiSenData1);
                    }

                }

            }


        } catch (EASBizException e) {
            //获取北森数据失败
            throw new RuntimeException(e);
        } catch (JSONException e) {
            throw new RuntimeException(e);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (SHRWebException e) {
            throw new RuntimeException(e);
        }


    }

    /**
     * 处理表单类型的主体信息
     *
     * @param id         关联的 ID
     * @param jsonObject 主体信息的 JSON 对象
     * @param fileJSON   文件信息的 JSON 数组
     * @return 保存后的对象主键
     * @throws JSONException   JSON 处理异常
     * @throws SHRWebException SHR 网页异常
     * @throws BOSException    BOS 异常
     * @throws EASBizException EAS 业务异常
     * @throws ParseException  解析异常
     * @throws IOException     输入输出异常
     */
    public String boyProcessing(UIViewInfo uiViewInfo, String id, JSONObject jsonObject, JSONArray fileJSON, String fileName,String beiSenData1)
            throws JSONException, SHRWebException, BOSException, EASBizException, ParseException, IOException {
        // 根据 UI 视图的主键生成动态 UI 视图信息
        com.kingdee.shr.base.syssetting.web.dynamic.model.UIViewInfo uiViewInfo1 =
                generateUIView(context, uiViewInfo.getUipk());
        // 获取实体名称
        String entityName = uiViewInfo1.getEntityName();
        // 获取字段列表
        List<FieldInfo> fields = uiViewInfo1.getFields();
        // 根据实体名称获取对应的对象值类

        Class objectValueClass = MetaDataUtil.getObjectValueClass(entityName);
        // 创建对应的实体对象
        CoreBaseInfo coreBaseInfo = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass, entityName);
        // 处理字段信息
        JSONObject jsonObject2 = new JSONObject();
        jsonObject2.put(beiSenData1,jsonObject2);
        JSONArray jsonArray = this.fieldProcessing(fields, coreBaseInfo, jsonObject2, fileName);
        // 创建对应的业务对象
        ICoreBase bosObject = (ICoreBase) (BOSObjectFactory.createBOSObject(context, coreBaseInfo.getBOSType()));
        // 获取关联字段
        String relateField = uiViewInfo1.getRelatedField();
        // 根据 ID 获取对应的实体对象信息
        EntityObjectInfo entityObject = MetaDataUtil.getEntityObject(id);
        // 获取实体对象的全名称
        String fullName = entityObject.getFullName();
        // 根据全名称获取对应的对象值类
        Class objectValueClass1 = MetaDataUtil.getObjectValueClass(fullName);
        // 创建对应的实体对象
        CoreBaseInfo coreBaseInfo1 = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass1, fullName);
        // 设置实体对象的 ID
        coreBaseInfo1.setId(BOSUuid.read(id));
        // 将关联的实体对象设置到当前实体对象中
        coreBaseInfo.put(relateField, coreBaseInfo1);
        // 保存实体对象
        IObjectPK save = bosObject.save(coreBaseInfo);
        // 处理文件信息
        fileProcessor(save.toString(), null, jsonArray);

        // 获取文件信息的第一个 JSON 对象
        JSONObject jsonObject1 = fileJSON.getJSONObject(0);
        if (!save.toString().equals("")) {
            // 遍历字段列表
            for (int i = 0; i < fields.size(); i++) {
                // 获取单个字段信息
                FieldInfo fieldInfo = fields.get(i);
                // 获取字段的别名
                String alias = fieldInfo.getAlias();//CertificateNu
                // 获取字段的名称
                String name = fieldInfo.getName();//idCardNO
                if (!name.equals("attachments")) {
                    continue;
                }
                // 分割字段别名
                String[] split = alias.split("#");
                // 获取字段的属性
                Map<String, String> attributes = fieldInfo.getAttributes();
                // 获取数据的 UI 主键
                String uipk = attributes.get("data-uipk");
                // 获取文件信息
                JSONObject data = jsonObject1.getJSONObject(split[1]);
                if (data != null) {
                    // 获取下载链接
                    String downloadUrl = data.getString("downloadUrl");
                    // 分割下载链接
                    String[] split1 = downloadUrl.split(",");
                    // 获取文件名
                    String text = data.getString("text");
                    // 分割文件名
                    String[] split2 = text.split(",");
                    for (int k = 0; k < split1.length; k++) {
                        byte[] dataImg = new byte[0];
                        // 拼接完整的下载链接
                        String URL = "http:" + split1[k];
                        System.out.println("===========" + URL + "==========");
                        // 从网络下载文件数据
                        dataImg = helper.getBytesByNetURL(URL);
                        // 插入人员附件信息
                        insertPersonAttachment(split2[k], uipk, save.toString(), dataImg);
                    }
                }

            }


        }
        // 返回保存后的对象主键
        return save.toString();
    }

    /**
     * 处理列表类型的主体信息
     *
     * @param id         关联的 ID
     * @param jsonArray  主体信息的 JSON 数组
     * @param fileJSON   文件信息的 JSON 数组
     * @return 保存后的对象主键
     * @throws JSONException   JSON 处理异常
     * @throws SHRWebException SHR 网页异常
     * @throws BOSException    BOS 异常
     * @throws EASBizException EAS 业务异常
     * @throws ParseException  解析异常
     * @throws IOException     输入输出异常
     */
    public String boyProcessing(UIViewInfo uiViewInfo, String id, JSONArray jsonArray, JSONArray fileJSON, String fileName,String beiSenData1)
            throws JSONException, SHRWebException, BOSException, EASBizException, ParseException, IOException {
        // 根据 UI 视图的主键生成动态 UI 视图信息
        com.kingdee.shr.base.syssetting.web.dynamic.model.UIViewInfo uiViewInfo1 =
                generateUIView(context, uiViewInfo.getUipk());

        String fileId = "";
        // 获取实体名称
        String entityName = uiViewInfo1.getEntityName();
        // 获取字段列表
        List<FieldInfo> fields = uiViewInfo1.getFields();
        // 获取关联字段
        String relateField = uiViewInfo1.getRelatedField();

        // 根据 ID 获取对应的实体对象信息
        EntityObjectInfo entityObject = MetaDataUtil.getEntityObject(id);
        // 获取实体对象的全名称
        String fullName = entityObject.getFullName();
        // 根据全名称获取对应的对象值类
        Class objectValueClass1 = MetaDataUtil.getObjectValueClass(fullName);
        // 创建对应的实体对象
        CoreBaseInfo coreBaseInfo1 = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass1, fullName);
        // 设置实体对象的 ID
        coreBaseInfo1.setId(BOSUuid.read(id));
        // 获取排序方法
        String sorterMethod = uiViewInfo1.getOrderBy();
        // 遍历主体信息的 JSON 数组
        for (int i = 0; i < jsonArray.size(); i++) {
            // 根据实体名称获取对应的对象值类
            Class objectValueClass = MetaDataUtil.getObjectValueClass(entityName);
            // 创建对应的实体对象
            CoreBaseInfo coreBaseInfo = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass, entityName);
            // 处理字段信息
            JSONObject jsonObject = new JSONObject();
            jsonObject.put(beiSenData1, jsonArray.getJSONObject(i));
            JSONArray jsonArray1 = this.fieldProcessing(fields, coreBaseInfo,jsonObject , fileName);
            // 创建对应的业务对象
            ICoreBase bosObject = (ICoreBase) (BOSObjectFactory.createBOSObject(context, coreBaseInfo.getBOSType()));
            // 将关联的实体对象设置到当前实体对象中
            coreBaseInfo.put(relateField, coreBaseInfo1);
            // 设置是否最高的标志
            coreBaseInfo.put("IsHighest", "1");
            // 设置是否单个的标志
            coreBaseInfo.put("isSingle", "1");
            // 保存实体对象
            IObjectPK save = bosObject.save(coreBaseInfo);

            if (sorterMethod != null && !sorterMethod.equals("")) {
                // 根据关联字段和排序方法查询实体对象集合
                CoreBaseCollection collection = bosObject.getCollection(" where " + relateField + " = '" + id + "' order by " + sorterMethod);
                if (collection.size() > 1) {
                    // 获取第一个实体对象
                    CoreBaseInfo coreBaseInfo2 = collection.get(0);
                    // 设置是否最高的标志
                    coreBaseInfo2.put("IsHighest", "1");
                    // 设置是否单个的标志
                    coreBaseInfo2.put("isSingle", "1");
                    // 保存实体对象
                    IObjectPK save1 = bosObject.save(coreBaseInfo2);
                    // 获取保存后的对象主键
                    fileId = save1.toString();
                    for (int j = 1; j < collection.size(); j++) {
                        // 获取其他实体对象
                        CoreBaseInfo coreBaseInfo3 = collection.get(j);
                        // 设置是否最高的标志
                        coreBaseInfo3.put("IsHighest", "0");
                        // 设置是否单个的标志
                        coreBaseInfo3.put("isSingle", "0");
                        // 保存实体对象
                        bosObject.save(coreBaseInfo3);
                    }
                }
            }
            // 处理文件信息
            fileProcessor(save.toString(), null, jsonArray1);
        }
        if (fileJSON!=null){
            // 获取文件信息的第一个 JSON 对象
            JSONObject jsonObject = fileJSON.getJSONObject(0);
            if (!fileId.equals("")) {
                // 遍历字段列表
                for (int i = 0; i < fields.size(); i++) {
                    // 获取单个字段信息
                    FieldInfo fieldInfo = fields.get(i);
                    // 获取字段的别名
                    String alias = fieldInfo.getAlias();//CertificateNu
                    // 获取字段的名称
                    String name = fieldInfo.getName();//idCardNO
                    if (!name.equals("attachments")) {
                        continue;
                    }
                    // 分割字段别名
                    String[] split = alias.split("#");
                    // 获取字段的属性
                    Map<String, String> attributes = fieldInfo.getAttributes();
                    // 获取数据的 UI 主键
                    String dataUipk = attributes.get("data-uipk");
                    // 获取文件信息
                    JSONObject data = jsonObject.getJSONObject(split[1]);
                    if (data != null) {
                        // 获取下载链接
                        String downloadUrl = data.getString("downloadUrl");
                        // 分割下载链接
                        String[] split1 = downloadUrl.split(",");
                        // 获取文件名
                        String text = data.getString("text");
                        // 分割文件名
                        String[] split2 = text.split(",");
                        for (int k = 0; k < split1.length; k++) {
                            byte[] dataImg = new byte[0];
                            // 拼接完整的下载链接
                            String URL = "http:" + split1[k];
                            System.out.println("===========" + URL + "==========");
                            // 从网络下载文件数据
                            dataImg = helper.getBytesByNetURL(URL);
                            // 插入人员附件信息
                            insertPersonAttachment(split2[k], dataUipk, fileId, dataImg);
                        }
                    }

                }
            }
        }


        return null;
    }

    /**
     * 处理字段信息
     *
     * @param fields       字段列表
     * @param coreBaseInfo 实体对象
     * @param jsonObject   数据的 JSON 对象
     * @return 处理后的文件信息的 JSON 数组
     * @throws JSONException      JSON 处理异常
     * @throws ShrWebBizException SHR 网页业务异常
     * @throws BOSException       BOS 异常
     * @throws ParseException     解析异常
     */
    public JSONArray fieldProcessing(List<FieldInfo> fields, CoreBaseInfo coreBaseInfo, JSONObject jsonObject, String fileName) throws JSONException, ShrWebBizException, BOSException, ParseException {
        System.out.println("===============+"+jsonObject);
        // 用于存储处理后的文件信息的 JSON 数组
        JSONArray files = new JSONArray();
        // 用于存储单个文件信息的 JSON 对象
        JSONObject file = null;
        // 遍历字段列表
        for (int i = 0; i < fields.size(); i++) {

            // 获取单个字段信息
            FieldInfo fieldInfo = fields.get(i);
            // 获取字段的属性信息
            PropertyInfo property = fieldInfo.getProperty();
            // 获取字段的数据类型
            DataType dataType = fieldInfo.getDataType();
            // 获取字段的别名
            String alias = fieldInfo.getAlias();//CertificateNumber.value
            // 获取字段的名称
            String name = fieldInfo.getName();//idCardNO
            // 分割字段别名
            String[] split = alias.split("#");
            Object value = null;
            // 获取字段的属性
            Map<String, String> attributes = fieldInfo.getAttributes();
            ;
            Object dataObject = jsonObject.get(split[0]);
            String s1 = attributes.get("data-valueType");
            if (s1!=null&&s1.equals("url")) {
                if (dataObject instanceof JSONObject){
                    JSONObject data = jsonObject.getJSONObject(split[0]);
                    if (data!=null){
                        file = new JSONObject();
                        value = data.get(split[1]);
                        if (value instanceof JSONObject){
                            value = data.getJSONObject(split[1]).get(split[2]);
                            if (value instanceof  JSONArray){
                                JSONArray jsonArray = data.getJSONObject(split[1]).getJSONArray(split[2]);
                                String tempValue="";
                                for (int j = 0; j < jsonArray.size(); j++) {
                                    String string = jsonArray.getString(j);
                                    // 将数据的 UI 主键、下载链接和文件名添加到文件信息的 JSON 对象中
                                    file.put("uipk", attributes.get("data-uipk"));
                                    file.put("url", string);
                                    file.put("name", data.getString("text"));
                                    // 将文件信息的 JSON 对象添加到文件信息的 JSON 数组中
                                    files.add(file);
                                }
                                continue;
                            }
                        }
                        if (value == null || value.equals("null") || value.equals("{}")||value.equals("")) {
                            continue;
                        }
                        // 将数据的 UI 主键、下载链接和文件名添加到文件信息的 JSON 对象中
                        file.put("uipk", attributes.get("data-uipk"));
                        file.put("url", value);
                        file.put("name", data.getString("text"));
                        // 将文件信息的 JSON 对象添加到文件信息的 JSON 数组中
                        files.add(file);
                    }

                }else if(dataObject instanceof JSONArray){
                    JSONArray jsonArray1 = jsonObject.getJSONArray(split[0]);
                    for (int j = 0; j < jsonArray1.size(); j++) {
                        JSONObject data = jsonArray1.getJSONObject(j);
                        if (data!=null){
                            file = new JSONObject();
                            value = data.get(split[1]);
                            if (value instanceof JSONObject){
                                value = data.getJSONObject(split[1]).get(split[2]);
                                if (value instanceof  JSONArray){
                                    JSONArray jsonArray = data.getJSONObject(split[1]).getJSONArray(split[2]);
                                    String tempValue="";
                                    for (int k = 0; k < jsonArray.size(); k++) {
                                        String string = jsonArray.getString(k);
                                        // 将数据的 UI 主键、下载链接和文件名添加到文件信息的 JSON 对象中
                                        file.put("uipk", attributes.get("data-uipk"));
                                        file.put("url", string);
                                        file.put("name", data.getString("text"));
                                        // 将文件信息的 JSON 对象添加到文件信息的 JSON 数组中
                                        files.add(file);
                                    }
                                    continue;
                                }
                            }
                            if (value == null || value.equals("null") || value.equals("{}")||value.equals("")) {
                                continue;
                            }
                            // 将数据的 UI 主键、下载链接和文件名添加到文件信息的 JSON 对象中
                            file.put("uipk", attributes.get("data-uipk"));
                            file.put("url", value);
                            file.put("name", data.getString("text"));
                            // 将文件信息的 JSON 对象添加到文件信息的 JSON 数组中
                            files.add(file);

                        }
                    }
                    continue;
                }



            }
            JSONObject data = jsonObject.getJSONObject(split[0]);
            // 获取数据的 JSON 对象

            if (data == null) {
                // 如果数据为空，获取默认值
                value = attributes.get("data-defaultValue");
            } else {
                // 获取数据的值
                value = data.get(split[1]);

                if (value == null) {
                    // 如果值为空，获取默认值
                    value = attributes.get("data-defaultValue");
                } else {
                    value = data.get(split[1]);
                    if (value instanceof JSONObject){
                        value = data.getJSONObject(split[1]).get(split[2]);
//                        if (value instanceof  JSONArray){
//                            JSONArray jsonArray = data.getJSONObject(split[1]).getJSONArray(split[2]);
//                            String tempValue="";
//                            if (jsonArray.size()>0) {
//                                String string = jsonArray.getString(0);
//                                value
//                            }
//                            if (!tempValue.equals("")){
//                                value = tempValue.substring(0,tempValue.length()-1);
//                            }
//                        }
                    }else if (value instanceof JSONArray){
                        JSONArray jsonArray = data.getJSONArray(split[1]);
                        if (jsonArray.size()>0){
                            Object o = jsonArray.get(0);
                            if (o instanceof  JSONObject){
                                Object string = jsonArray.getJSONObject(0).get(split[2]);
                                if (string instanceof Integer){
                                    value = jsonArray.getJSONObject(0).getInteger(split[2]);
                                }else  if (o instanceof  String){
                                    value = jsonArray.getJSONObject(0).getString(split[2]);
                                }
                            }
                        }
                    }else {
                        value = data.getString(split[1]);
                    }
                    // 获取自定义映射值
                    String s = attributes.get("data-mappingValue");
                    if (s != null && !s.equals("")) {
                        // 解析自定义映射值的 JSON 对象
                        JSONObject jsonObject1 = JSONObject.parseObject(s);
                        if (jsonObject1 != null) {
                            // 根据值获取映射后的值
                            String string = jsonObject1.getString(value.toString());
                            if (string != null) {
                                value = string;
                            }

                        }
                    }

                }
            }
            if (value == null || value.equals("")) {
                // 如果值为空，打印日志并跳过处理
                System.out.println("+++++++++" + value);
                continue;
            }
            if (dataType != null && dataType.getName().equals("ObjectValue")) {
                if (property instanceof LinkPropertyInfo) {
                    // 获取关联对象的全名称
                    String businessImplName = ((LinkPropertyInfo) property).getRelationship().getSupplierObject().getFullName();
                    // 根据全名称获取对应的对象值类
                    Class objectValueClass1 = MetaDataUtil.getObjectValueClass(businessImplName);
                    // 创建对应的实体对象
                    CoreBaseInfo coreBaseInfo1 = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass1, businessImplName);

                    // 创建对应的业务对象
                    ICoreBase bosObject = (ICoreBase) (BOSObjectFactory.createBOSObject(context, coreBaseInfo1.getBOSType()));

                    // 根据名称或编号查询实体对象集合
                    CoreBaseCollection dataBaseCollection = bosObject.getCollection("where name like '%" + value + "%' or number = '" + value + "'");
                    if (dataBaseCollection.size() <= 0) {
                        // 如果集合为空，将字段的值设置为 null
                        // coreBaseInfo.put(name, null);
                    } else {
                        // 将查询到的第一个实体对象设置到当前实体对象中
                        //coreBaseInfo.put(name, dataBaseCollection.get(0));
                        setCoreBaseInfo(coreBaseInfo,name, dataBaseCollection.get(0));
                    }

                }
            } else if (dataType != null && dataType.getName().equals("Enum")) {
                // 如果数据类型为枚举，将值设置到当前实体对象中
                //coreBaseInfo.put(name, value);
                setCoreBaseInfo(coreBaseInfo,name,value);
            } else if (dataType != null && dataType.getName().equals("Date")) {
                // 创建日期格式化对象
                SimpleDateFormat f = new SimpleDateFormat(attributes.get("dateFormat"));
                if (!value.equals("") || !value.equals("未知") || !value.equals("9999/12")) {
                    // 将日期字符串解析为日期对象并设置到当前实体对象中
                    //coreBaseInfo.put(name, f.parse(value));
                    setCoreBaseInfo(coreBaseInfo,name, f.parse(value.toString()));
                }
            } else {
                if (jsonObject.getJSONObject("staffInfos").getString("idCardType") != null
                        && name.equals("entrys.IDCardNo")) {
                    // 获取证件类型的 JSON 对象
                    JSONObject string = jsonObject.getJSONObject("CertificateType");
                    // 获取证件类型的值
                    String string1 = jsonObject.getJSONObject("staffInfos").getString("idCardType");
                    if ("1".equals(string1)) {
                        // 如果证件类型为 1，将值设置到身份证号码字段中
                        //coreBaseInfo.put(name, value);
                        setCoreBaseInfo(coreBaseInfo,name,value);
                    } else {
                        // 否则，将值设置到护照号码字段中
                        //coreBaseInfo.put("passportNO", value);
                        setCoreBaseInfo(coreBaseInfo,"entrys.passportNO", value);
                    }
                } else {
                    setCoreBaseInfo(coreBaseInfo,name,value);
                    // 将值设置到当前实体对象中
                    //coreBaseInfo.put(name, value);
                }


            }
        }
        // 返回处理后的文件信息的 JSON 数组
        return files;
    }
    public void setCoreBaseInfo(CoreBaseInfo coreBaseInfo,String name,Object value){
        if (name.indexOf(".")>=0){
            String[] split = name.split("\\.");
            Object o = coreBaseInfo.get(split[0]);
            if (o instanceof  EmpEnrollBizBillEntryInfo){
                ((CoreBaseInfo) o).put(split[1],value);
            }else if (o instanceof EmpEnrollBizBillEntryCollection){
                EmpEnrollBizBillEntryCollection collection =  ((EmpEnrollBizBillEntryCollection) o);
                EmpEnrollBizBillEntryInfo objectValue=null;
                if (collection.size()==0){
                    objectValue= new EmpEnrollBizBillEntryInfo();
                    collection.add(objectValue);
                }else {
                    objectValue = collection.get(0);
                }
                objectValue.put(split[1],value);
                //collection.add(objectValue);
            }
        }else {
            coreBaseInfo.put(name,value);
        }
    }


    /**
     * 处理头部信息
     *
     * @param uiViewInfo 头部 UI 视图信息
     * @param jsonObject 人员信息的 JSON 对象
     * @param fileJSON   文件信息的 JSON 数组
     * @return 保存后的对象主键
     * @throws BOSException    BOS 异常
     * @throws SHRWebException SHR 网页异常
     * @throws EASBizException EAS 业务异常
     * @throws JSONException   JSON 处理异常
     * @throws ParseException  解析异常
     * @throws IOException     输入输出异常
     */
    public String headProcessing(UIViewInfo uiViewInfo, JSONObject jsonObject
            , JSONArray fileJSON, String fileName) throws BOSException, SHRWebException,
            EASBizException, JSONException, ParseException, IOException {
        // 根据 UI 视图的主键生成动态 UI 视图信息
        com.kingdee.shr.base.syssetting.web.dynamic.model.UIViewInfo uiViewInfo1 =
                generateUIView(context, uiViewInfo.getUipk());
        // 获取实体名称
        String entityName = uiViewInfo1.getEntityName();
        // 获取字段列表
        List<FieldInfo> fields = uiViewInfo1.getFields();
        // 根据实体名称获取对应的对象值类
        Class objectValueClass = MetaDataUtil.getObjectValueClass(entityName);
        // 创建对应的实体对象
        CoreBaseInfo coreBaseInfo = (CoreBaseInfo) MetaDataUtil.newInstance(objectValueClass, entityName);
        coreBaseInfo.getBOSType();
        // 处理字段信息
        JSONArray jsonArray = this.fieldProcessing(fields, coreBaseInfo, jsonObject, fileName);
        // 创建对应的业务对象
        ICoreBase bosObject = (ICoreBase) (BOSObjectFactory.createBOSObject(context, coreBaseInfo.getBOSType()));

        // 保存实体对象
        IObjectPK save = bosObject.save(coreBaseInfo);

        PersonInfo personInfo = (PersonInfo) coreBaseInfo.get("person");
        // 处理文件信息
        fileProcessor(save.toString(), personInfo, jsonArray);

        // 获取文件信息的第一个 JSON 对象
        if (fileJSON!=null){
            JSONObject jsonObject1 = fileJSON.getJSONObject(0);
            if (!save.toString().equals("")) {
                // 遍历字段列表
                for (int i = 0; i < fields.size(); i++) {
                    // 获取单个字段信息
                    FieldInfo fieldInfo = fields.get(i);
                    // 获取字段的别名
                    String alias = fieldInfo.getAlias();//CertificateNu
                    // 获取字段的名称
                    String name = fieldInfo.getName();//idCardNO
                    if (!name.equals(fileName)) {
                        continue;
                    }
                    // 分割字段别名
                    String[] split = alias.split("#");
                    // 获取字段的属性
                    Map<String, String> attributes = fieldInfo.getAttributes();
                    // 获取数据的 UI 主键
                    String uipk = attributes.get("data-uipk");
                    // 获取文件信息
                    JSONObject data = jsonObject1.getJSONObject(split[1]);

                    if (data != null) {
                        // 获取下载链接
                        JSONArray downloadUrl = data.getJSONArray("downloadUrls");
                        // 分割下载链接
                        // 获取文件名
                        //String text = data.getString("text");
                        // 分割文件名
                        //String[] split2 = text.split(",");
                        for (int k = 0; k < downloadUrl.size(); k++) {
                            byte[] dataImg = new byte[0];
                            // 拼接完整的下载链接
                            String URL = "http:" + downloadUrl.get(k);
                            System.out.println("===========" + URL + "==========");
                            // 从网络下载文件数据
                            dataImg = helper.getBytesByNetURL(URL);
                            // 插入人员附件信息
                            //insertPersonAttachment(split2[k], uipk, save.toString(), dataImg);
                        }
                    }


                }
            }
        }



        // 返回保存后的人员信息实体对象的主键
        return save.toString();
    }

    /**
     * 处理文件信息
     *
     * @param id         关联的 ID
     * @param personInfo 人员信息对象
     * @param jsonArray  文件信息的 JSON 数组
     * @throws JSONException JSON 处理异常
     */
    public void fileProcessor(String id, PersonInfo personInfo, JSONArray jsonArray) throws JSONException {
        // 遍历文件信息的 JSON 数组
        for (int i = 0; i < jsonArray.size(); i++) {
            // 获取单个文件信息
            JSONObject jsonObject1 = jsonArray.getJSONObject(i);
            // 获取数据的 UI 主键
            String uipk = jsonObject1.getString("uipk");
            // 获取文件的下载链接
            String url = jsonObject1.getString("url");
            // 获取文件的名称
            String name = jsonObject1.getString("name");
            if (url==null||url.toString().equals("")||url.toString().equals("[]")){
                continue;
            }
            if (uipk.equals("PersonPhoto")) {
                try {
                    if (personInfo != null) {
                        // 保存人员照片信息
                        savePersonPhoto(personInfo, url);
                    }

                } catch (IOException e) {
                    // 抛出运行时异常，表示保存人员照片信息失败
                    throw new RuntimeException(e);
                }
            } else {
                try {
                    // 从网络下载文件数据
                    byte[] dataImg = null;
                    if (url.indexOf("http:")>=0||url.indexOf("https:")>=0){
                        dataImg= helper.getBytesByNetURL(url);
                    }else {
                        dataImg= helper.getBytesByNetURL("http:" + url);
                    }


                    // 插入人员附件信息
                    if (name==null){
                        name = extractFileNameFromUrl(url);
                    }
                    insertPersonAttachment(name, uipk, id, dataImg);
                } catch (IOException e) {
                    // 抛出运行时异常，表示下载文件数据失败
                    throw new RuntimeException(e);
                } catch (BOSException e) {
                    // 抛出运行时异常，表示插入人员附件信息失败
                    throw new RuntimeException(e);
                } catch (EASBizException e) {
                    // 抛出运行时异常，表示插入人员附件信息失败
                    throw new RuntimeException(e);
                }
            }
        }
    }

    public static void main(String[] args) {
        String name = extractFileNameFromUrl("https://dfiles.italent.cn/download/recruitonboardingfile/433107/1753067254/3/66304e3e5cb7431f9fb1900ba675cee3.jpg?sig_t=1753070295&sig_exp=2592000&sig_a=recruitonboarding&sig_pm=8&sig_npm=2&sig_v=1&sig=41d7e3c49cef36421ff8c4c4bd4ff6b145810ca3");
        System.out.println(name);
    }
    // 从URL中提取文件名
    private static String extractFileNameFromUrl(String url) {
        if (url == null || url.isEmpty()) {
            return null;
        }

        int lastSlash = url.lastIndexOf('/');
        if (lastSlash != -1 && lastSlash < url.length() - 1) {
            String fileName = url.substring(lastSlash + 1);

            // 去除查询参数
            int queryIndex = fileName.indexOf('?');
            if (queryIndex != -1) {
                fileName = fileName.substring(0, queryIndex);
            }

            return fileName;
        }

        return null;
    }

    /**
     * 保存人员照片信息
     *
     * @param personInfo         人员信息对象
     * @param iDPhotoDownloadUrl 照片下载链接
     * @throws IOException 输入输出异常
     */
    private void savePersonPhoto(PersonInfo personInfo, String iDPhotoDownloadUrl) throws IOException {
        if (!StringUtils.isEmpty(iDPhotoDownloadUrl)) {
            // 打印照片下载链接
            System.out.println("iDPhotoDownloadUrl" + iDPhotoDownloadUrl);
            // 从网络下载照片数据
            byte[] dataImg = helper.getBytesByNetURL("http:" + iDPhotoDownloadUrl);
            // 创建人员照片信息对象
            PersonPhotoInfo personPhotoInfo = new PersonPhotoInfo();
            // 设置照片数据
            personPhotoInfo.setImageData(dataImg);
            // 设置关联的人员信息对象
            personPhotoInfo.setPerson(personInfo);
            try {
                // 保存人员照片信息
                PersonPhotoFactory.getLocalInstance(context)
                        .save(personPhotoInfo);
            } catch (EASBizException e) {
                e.printStackTrace();
            } catch (BOSException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 插入人员附件信息
     *
     * @param filename 文件名
     * @param uipk     数据的 UI 主键
     * @param boId     业务对象的 ID
     * @param data     文件数据
     * @return 附件的 ID
     * @throws BOSException    BOS 异常
     * @throws EASBizException EAS 业务异常
     */
    public String insertPersonAttachment(String filename, String uipk, String boId, byte[] data) throws BOSException, EASBizException {
        if (data.length > 20971520) {
            // 如果文件大小超过 20MB，抛出 BOS 异常
            throw new BOSException("文件上传失败，文件大小超过20MB！");
        } else if (!org.apache.commons.lang3.StringUtils.isBlank(filename) && !org.apache.commons.lang3.StringUtils.isBlank(boId) && data.length > 0) {
            // 创建 SHR 附件扩展信息对象
            SHRAttachmentExtInfo attchExt = new SHRAttachmentExtInfo();
            // 创建附件信息对象
            AttachmentInfo ai = new AttachmentInfo();
            // 获取管理员用户信息
            UserInfo userInfo = UserFactory.getLocalInstance(context).getUserInfo("where number = 'administrator'");
            // 获取用户 ID
            String userId = userInfo.getId().toString();
            // 设置附件名称
            ai.setName(filename.substring(0, filename.lastIndexOf(46)));
            // 设置附件简单名称
            ai.setSimpleName(filename.substring(filename.lastIndexOf(".") + 1));
            // 设置附件描述
            ai.setDescription("");
            // 设置附件文件数据
            ai.setFile(data);
            // 设置附件是否共享
            ai.setIsShared(false);
            // 设置附件共享描述
            ai.setSharedDesc("否");
            // 设置附件 ID
            ai.setAttachID("" + System.currentTimeMillis());
            // 设置附件类型
            ai.setType(this.getFileType(filename));
            // 将附件信息对象设置到 SHR 附件扩展信息对象中
            attchExt.setAttachment(ai);
            // 设置 SHR 附件扩展信息对象的名称
            attchExt.setName(filename);
            // 设置 SHR 附件扩展信息对象的属性名称
            attchExt.setPropertyName("null0");
            // 设置 SHR 附件扩展信息对象的类型
            attchExt.setType(AttachmentTypeEnum.FORM);
            // 设置 SHR 附件扩展信息对象的状态
            attchExt.setState(AttachmentState.UNSAVE);
            // 设置 SHR 附件扩展信息对象的绑定信息
            attchExt.setBunding(userId + "#" + uipk);
            // 设置 SHR 附件扩展信息对象关联的业务对象 ID
            attchExt.setBoID(boId);
            // 设置 SHR 附件扩展信息对象的状态
            attchExt.setState(AttachmentState.SAVE);
            // 保存附件信息对象
            AttachmentFactory.getLocalInstance(context).save(ai);
            // 设置 SHR 附件扩展信息对象的状态
            attchExt.setState(AttachmentState.SAVE);
            // 创建业务对象与附件关联信息对象
            BoAttchAssoInfo boAttchAssoInfo = new BoAttchAssoInfo();
            // 设置业务对象与附件关联信息对象关联的业务对象 ID
            boAttchAssoInfo.setBoID(boId);
            // 设置业务对象与附件关联信息对象关联的业务对象类型
            boAttchAssoInfo.setAssoBusObjType(String.valueOf(BOSUuid.getBOSObjectType(boId, true)));
            // 设置业务对象与附件关联信息对象的关联类型
            boAttchAssoInfo.setAssoType("Added Accessories");
            // 将附件信息对象设置到业务对象与附件关联信息对象中
            boAttchAssoInfo.setAttachment(ai);
            // 保存业务对象与附件关联信息对象
            BoAttchAssoFactory.getLocalInstance(context).save(boAttchAssoInfo);
            // 保存 SHR 附件扩展信息对象
            SHRAttachmentExtFactory.getLocalInstance(context).save(attchExt);
            // 返回附件的 ID
            return ai.getId().toString();
        } else {
            // 如果文件名、业务对象 ID 或文件数据为空，抛出 BOS 异常
            throw new BOSException("文件上传失败，请确认信息无误！");
        }
    }

    /**
     * 根据文件名获取文件类型
     *
     * @param fullname 文件名
     * @return 文件类型
     */
    private String getFileType(String fullname) {
        // 获取文件扩展名
        String extname = fullname.substring(fullname.lastIndexOf(".") + 1, fullname.length());
        if (!"doc".equalsIgnoreCase(extname) && !"docx".equalsIgnoreCase(extname)) {
            if (!"xls".equalsIgnoreCase(extname) && !"xlsx".equalsIgnoreCase(extname) && !"xlsm".equalsIgnoreCase(extname) && !"xlsb".equalsIgnoreCase(extname)) {
                if (!"ppt".equalsIgnoreCase(extname) && !"pptx".equalsIgnoreCase(extname) && !"pptm".equalsIgnoreCase(extname)) {
                    return "txt".equalsIgnoreCase(extname) ? "TEXT 文本文件" : "未知文件类型(." + extname + ")";
                } else {
                    return "Microsoft PowerPoint 幻灯片";
                }
            } else {
                return "Microsoft Excel 表格";
            }
        } else {
            return "Microsoft Word 文档";
        }
    }

    /**
     * 根据 UI 视图的主键生成动态 UI 视图信息
     *
     * @param ctx  上下文对象
     * @param uipk UI 视图的主键
     * @return 动态 UI 视图信息
     * @throws SHRWebException SHR 网页异常
     */
    private com.kingdee.shr.base.syssetting.web.dynamic.model.UIViewInfo generateUIView(Context ctx, String uipk) throws SHRWebException {
        // 从数据库中获取 UI 视图信息
        com.kingdee.shr.base.syssetting.UIViewInfo dbUIViewInfo = getUIViewFromDB(ctx, uipk);
        if (dbUIViewInfo == null) {
            if (uipk.contains(" ")) {
                // 如果 UI 视图主键包含空格，抛出 SHR 网页业务异常
                throw new ShrWebBizException(MessageFormat.format(SHRWebResource.getString("com.kingdee.shr.base.syssetting.SHRSyssettingResource", "view_contain_blank"), uipk));
            } else {
                // 如果 UI 视图信息为空，抛出 SHR 网页业务异常
                throw new ShrWebBizException(SHRWebResource.getString("com.kingdee.shr.base.syssetting.SHRSyssettingResource", "view_not_found"));
            }
        } else {
            // 处理树导航元素
            dealTreeNavigationElement(dbUIViewInfo);
            // 获取 UI 视图转换器
            IUIViewConverter converter = UIViewConverterFactory.getUIViewConverter(dbUIViewInfo, ctx);
            // 执行转换操作
            return converter.exec();
        }
    }

    /**
     * 处理树导航元素
     *
     * @param dbUIViewInfo UI 视图信息
     */
    private void dealTreeNavigationElement(com.kingdee.shr.base.syssetting.UIViewInfo dbUIViewInfo) {
        // 处理配置信息
        String content = dealConfig(dbUIViewInfo.getContent());
        // 处理扩展配置信息
        String extend = dealConfig(dbUIViewInfo.getExtend());
        if (!StringUtils.isEmpty(content)) {
            // 如果处理后的配置信息不为空，设置到 UI 视图信息中
            dbUIViewInfo.setContent(content);
        }

        if (!StringUtils.isEmpty(extend)) {
            // 如果处理后的扩展配置信息不为空，设置到 UI 视图信息中
            dbUIViewInfo.setExtend(extend);
        }

    }

    /**
     * 从数据库中获取 UI 视图信息
     *
     * @param ctx  上下文对象
     * @param uipk UI 视图的主键
     * @return UI 视图信息
     * @throws SHRWebException SHR 网页异常
     */
    public com.kingdee.shr.base.syssetting.UIViewInfo getUIViewFromDB(Context ctx, String uipk) throws SHRWebException {
        try {
            if (LocaleUtils.locale_zh_CN.toString().equals(LocaleUtils.getLocaleString(LocaleUtils.getFirstOriginLocale(ctx.getLocale())))) {
                // 如果是中文环境，根据 UI 视图主键和选择器从数据库中获取 UI 视图信息
                return UIViewFactory.getLocalInstance(ctx).getValueByUipk(uipk, SysSettingUIViewUtil.getUIViewSelector());
            } else {
                // 如果不是中文环境，使用多语言服务进行转换
                Map<String, Object> params = new HashMap();
                params.put("uipks", uipk);
                params.put("isConvert", true);
                Object obj = MLServiceFactory.getLocalInstance(ctx).convert(ResourceType.UIView, params);
                return null == obj ? null : (com.kingdee.shr.base.syssetting.UIViewInfo) obj;
            }
        } catch (BOSException var4) {
            // 抛出 SHR 网页业务异常
            throw new ShrWebBizException(var4.getMessage(), var4);
        } catch (EASBizException var5) {
            // 抛出 SHR 网页业务异常
            throw new ShrWebBizException(var5.getMessage(), var5);
        }
    }

    /**
     * 处理配置信息
     *
     * @param text 配置信息文本
     * @return 处理后的配置信息
     */
    private String dealConfig(String text) {
        if (StringUtils.isEmpty(text)) {
            return null;
        } else {
            try {
                // 获取 XML 输出器
                XMLOutputter output = XMLUtil.getXMLOutputter();
                // 解析 XML 文本
                Document doc = XMLUtil.parseXML(text);
                // 获取根元素
                Element rootElement = doc.getRootElement();
                // 创建树导航 XPath 对象
                XPath xPathTreeNavigation = XPath.newInstance("//treeNavigation");
                // 创建过滤器项 XPath 对象
                XPath xPathFilterItem = XPath.newInstance("//filterItem[@isAdminOrg='true']");
                // 获取树导航元素列表
                List<Element> treeNavigations = xPathTreeNavigation.selectNodes(rootElement);
                // 获取过滤器项元素列表
                List<Element> filterItems = xPathFilterItem.selectNodes(rootElement);
                if (null != treeNavigations && treeNavigations.size() > 0) {
                    if (null != filterItems && filterItems.size() > 0) {
                        // 遍历树导航元素列表
                        Iterator i$ = treeNavigations.iterator();

                        while (i$.hasNext()) {
                            // 获取单个树导航元素
                            Element e = (Element) i$.next();
                            // 获取父元素
                            Element parent = e.getParent();
                            // 从父元素中移除树导航元素
                            parent.removeContent(e);
                        }

                        // 输出处理后的 XML 文本
                        String r = output.outputString(doc);
                        return r;
                    } else {
                        return null;
                    }
                } else {
                    return null;
                }
            } catch (Exception var11) {
                return null;
            }
        }
    }

}