package com.malk.eastar.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.malk.eastar.conf.EastarParam;
import com.malk.eastar.service.YidaService;
import com.malk.eastar.util.ConfigDataProcessor;
import com.malk.server.aliwork.YDConf;
import com.malk.server.aliwork.YDParam;
import com.malk.server.aliwork.YDSearch;
import com.malk.server.dingtalk.DDR_New;
import com.malk.service.aliwork.YDClient;
import com.malk.service.aliwork.YDService;
import com.malk.utils.PublicUtil;
import com.malk.utils.UtilMap;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;

/**
 * 专用于宜搭复杂逻辑处理的接口服务
 * add by Jason 20260317
 */
@Slf4j
@Service
public class YidaServiceImpl implements YidaService {

    @Autowired
    private YDClient ydClient;

    @Autowired
    private YDService ydService;

    @Override
    public Map heartbeatTest(String param) {
        Map<String,Object> result = new LinkedHashMap<>();
        if("EastarProgram".equals(param)){
            result.put("col1","Eastar");
            result.put("col2",888888);
            result.put("col3", DateUtil.now());
        }else{
            result.put("error","错误的哦！");
        }
        return result;
    }

    @Override
    public Map createPartsTask(String formInstId) {
        log.info("【项目台账】→【采购任务】数据流转开始");
        /*
            LTC全生命周期
            Leads to Order
            Order to Product
            Product to Cash
         */

        /*
            查询项目数据
            【项目台账】   FORM-D8DFF1F8C07A4869BCC850090F3A3B4EE0AV
         */
        Map projectData = ydClient.queryData(
                YDParam.builder().formInstId(formInstId).build(),
                YDConf.FORM_QUERY.retrieve_id
        ).getFormData();    //【项目台账】数据，旧变量名 -> data
        String projectCode = UtilMap.getString(projectData,"textField_me2hyldc");  // 项目编号（立项流程），旧变量名 -> pId
        log.info("项目编号（立项流程）："+projectCode);
        String projectName = UtilMap.getString(projectData,"textField_me87x1nz");    // 项目名称（立项流程），旧变量名 -> pName
        log.info("项目名称（立项流程）："+projectName);
        String testFlag = UtilMap.getString(projectData,"radioField_mp4t9q57");  //测试使用
        log.info("测试使用："+testFlag);
        //String pTaskType = UtilMap.getString(projectData,"textField_mfqnsa9d");    // TB任务类型名称
        String customerName = UtilMap.getString(projectData,"textField_me87x1o0");  // 客户公司名（英文名），旧变量名 -> merName
        log.info("客户公司名（英文名）："+customerName);
        String projectOrderType = UtilMap.getString(projectData,"selectField_mdf997wp");  // 订单类型（大货|打样）
        List<String> projectPhaseList = UtilMap.getList(projectData,"checkboxField_me9n37rs");   //包含阶段，旧变量名 -> jds
        List<String> ssUserId = (List<String>) UtilMap.getList(projectData, "employeeField_me2hyld9_id");  // 业务员 userid
        List<String> ssmUserId = (List<String>) UtilMap.getList(projectData, "employeeField_mp6mn6je_id");  // 业务组长 userid
        List<String> pmUserId = (List<String>) UtilMap.getList(projectData, "employeeField_me2hyld8_id");  // PM userid
        List<String> qaUserId = (List<String>) UtilMap.getList(projectData, "employeeField_me9n24ka_id");  // QA userid
        List<UtilMap.assDetail> projectDataAssLeads = UtilMap.getAssFieldValue(
                projectData,"associationFormField_mdy7w1wn_id"
        );  //【项目台账】关联表单【销售项目】
        String leadsCode = UtilMap.getString(projectData,"textField_me2hyldb");  // 项目编号，旧变量名 -> pMainId
        log.info("项目编号："+leadsCode);
        String leadsName = UtilMap.getString(projectData,"textField_me9n24kq");    // 项目名称，旧变量名 -> pMainName
        log.info("项目名称："+leadsName);
        String devNumFlag = UtilMap.getString(projectData,"radioField_mmkb0vkc");  //研发部是否需要留样
        log.info("研发部是否需要留样："+devNumFlag);
        List<UtilMap.assDetail> projectDataAssOrder = UtilMap.getAssFieldValue(
                projectData,"associationFormField_me2hylda_id"
        );  //【项目台账】关联表单【销售订单】，旧变量名 -> projectOrder
        List<Map> projectSubDataPlan = UtilMap.getList(
                projectData,"tableField_mgu5rm3e"
        ); // 【项目台账】子表单【项目计划】，旧变量名 -> projectPlan
        List<Map> projectSubDataParts = ydService.queryDetails(
                YDParam.builder()
                        .formInstanceId(formInstId)
                        .formUuid(EastarParam.YD_FORMUUID_PROJECT)
                        .tableFieldId("tableField_mdy8x198").build()
        );  // 【项目台账】子表单【全品类】，旧变量名 -> table
        List<Map> projectSubDataLang = ydService.queryDetails(
                YDParam.builder()
                        .formInstanceId(formInstId)
                        .formUuid(EastarParam.YD_FORMUUID_PROJECT)
                        .tableFieldId("tableField_mn6vamoe").build()
        );  // 【项目台账】子表单【语言版本 - 数量拆分】
        List<Map> projectSubDataBuyer = UtilMap.getList(
                projectData,"tableField_mec6juik"
        );  // 【项目台账】子表单【跟单员列表】，旧变量名 -> mchTable

        /*
            查询销售订单数据
            【销售订单】   FORM-A731443BE0F04467A5D7FC1A82431D6AL2JO
         */
        String orderId = projectDataAssOrder.get(0).instanceId; // 销售订单实例ID，旧变量名 -> orderFid
        Map orderData = ydClient.queryData(
                YDParam.builder().formInstId(orderId).build(),
                YDConf.FORM_QUERY.retrieve_id
        ).getFormData();    //【销售订单】数据
        int sampleNum;  //套装样品数量
        Object demoValue = orderData.get("textField_me2f7tvd"); //套装样品及数量（单行文本类型）
        // 检查值是否为 Integer 类型
        if (demoValue == null) {
            sampleNum = 0;
        }else if (demoValue instanceof Integer) {
            sampleNum = (Integer) demoValue;
        } else if (demoValue instanceof String) {
            try {
                sampleNum = Integer.parseInt((String) demoValue);
            } catch (NumberFormatException e) {
                // 解析失败
                System.err.println("套装样品及数量字段值不是整数！");
                sampleNum = 0;
            }
        }else{
            System.err.println("套装样品及数量字段值不是整数！");
            sampleNum = 0;
        }
        List<Map> orderSubDataSeries = UtilMap.getList(orderData,"tableField_mesc7nvj");    // 【销售订单】子表单【系列套数】，旧变量名 -> xlConf
        System.out.println("【销售订单】子表单【系列套数】");
        String codeSeries;
        String nameSeries;
        int numOfSetsSeries;    //套数
        for(Map orderSubRecordSeries : orderSubDataSeries){    //遍历子表单记录
            codeSeries = UtilMap.getString(orderSubRecordSeries,"textField_mizmmf8m");    // 系列编号【系列套数】
            nameSeries = UtilMap.getString(orderSubRecordSeries,"textField_mesc7nvf");    // 系列【系列套数】
            numOfSetsSeries = UtilMap.getInt(orderSubRecordSeries,"numberField_mesc7nvi");    // 套数【系列套数】
            System.out.println("系列："+nameSeries+"，系列编号："+codeSeries+"，套数："+numOfSetsSeries);
        }
        List<Map> orderSubDataLang = UtilMap.getList(orderData,"tableField_meqqj4we");  // 【销售订单】子表单【语言版本 - 数量拆分】，旧变量名 -> orderLangConf
        System.out.println("【销售订单】子表单【语言版本 - 数量拆分】");
        String codeLang;
        String nameLang;
        int numOfSetsAll;   //总套数
        for(Map orderSubRecordLang : orderSubDataLang){  //遍历子表单记录
            codeSeries = UtilMap.getString(orderSubRecordLang,"textField_mizmmf8h");    // 系列编号【语言版本 - 数量拆分】
            nameSeries = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wa");    // 系列【语言版本 - 数量拆分】
            codeLang = UtilMap.getString(orderSubRecordLang,"textField_mizmmf8i");    // 语言编号【语言版本 - 数量拆分】
            nameLang = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wb");    // 语言【语言版本 - 数量拆分】
            numOfSetsSeries = UtilMap.getInt(orderSubRecordLang,"numberField_meqqj4wd");    // 套数【语言版本 - 数量拆分】
            numOfSetsAll = UtilMap.getInt(orderSubRecordLang,"numberField_mmtymctd");    // 总套数【语言版本 - 数量拆分】
//            System.out.println("系列编号："+codeSeries+"，系列："+nameSeries+"，语言编号："+codeLang+"，语言："+nameLang
//                    +"，套数："+numOfSetsSeries+"，总套数："+numOfSetsAll);
        }

        /*
            获取供应商与采购跟单数据（当前项目）
         */
        List<String> buyerUserIdList = new ArrayList<>();   //采购跟单userid列表，旧变量名 -> mchList
        String supplier;
        String buyerUserId;
        Map<String,String> supplierBuyerMap = new HashMap<>();  //供应商与采购跟单userid映射，旧变量名 -> mchDDIdMap
        for (Map projectSubRecordBuyer : projectSubDataBuyer){    //遍历跟单员列表，旧变量名 -> map
            buyerUserId = String.valueOf(
                    UtilMap.getList(projectSubRecordBuyer, "employeeField_me9n24kl_id") //跟单员
                            .get(0)
            );  //跟单员userid，旧变量名 -> ddId
            if(!buyerUserIdList.contains(buyerUserId)){
                buyerUserIdList.add(buyerUserId);
            }
            supplier = UtilMap.getString(projectSubRecordBuyer,"textField_mec6juil"); //供应商
            supplierBuyerMap.put(supplier, buyerUserId);
        }

        /*
            查询配件类型信息
            【品类档案】  FORM-17E244F3FB2240EB930E6DD4E22C7F89KXAR
         */
        List<Map> partsTypeData = ydService.queryAllFormData(
                YDParam.builder().formUuid(EastarParam.YD_FORMUUID_SKU_TYPE).build()
        );  // 【品类档案】数据，旧变量名 -> skuTypeListConfigData
        Map partsTypeNameCodeMap = ConfigDataProcessor.skuTypeListConfigData(partsTypeData);  // 品类名称与配件编号（这里的配件编号应该是品类编码）映射，旧变量名 -> skuIdMap

        /*
            查询配件参数信息
            【配件状态档案】  FORM-760F4001E1C743BA8527721F7217E068534G
         */
        List<Map> partsConfSubDataDetails = ydService.queryDetails(
                YDParam.builder()
                        .formInstanceId("FINST-X1B66Y81IUFY9U417XIUE99I8YV93HGMJ8WEMF")
                        .formUuid(EastarParam.YD_FORMUUID_SONCONF)
                        .tableFieldId("tableField_mew7d9f3").build()
        );  // 【配件状态档案】子表单【明细】，旧变量名 -> sonConfData
        Map<String,Map<String,List<String>>>  partsConfMap = ConfigDataProcessor.processConfigData(
                partsConfSubDataDetails
        );  //配件参数信息（按配件大类分组），旧变量名 -> sonConf

        /*
            获取立项相关成员数据
         */
//        List<String> userIdList;
//        userIdList = new ArrayList<>();   //立项相关成员userid列表，旧变量名 -> userIdList
//        userIdList.addAll(pmUserId);
//        userIdList.addAll(ssUserId);
//        userIdList.addAll(qeUserId);
//        userIdList.addAll(buyerUserIdList);
//        Set<String> userIdSet = new HashSet<>(userIdList);    //立项相关成员userid列表（不重复），旧变量名 -> set
//        userIdList = new ArrayList<>(userIdSet);

        /*
            获取系列语言与研发部订单需求数量映射
         */
        Map<String,String> seriesLangDevNumMap = new HashMap<>();  //系列语言与研发部订单需求数量映射数据
        String devNum;  //研发部订单需求数量
        for(Map projectSubRecordLang : projectSubDataLang) { //遍历【项目台账】子表单【语言版本 - 数量拆分】数据
            nameSeries = UtilMap.getString(projectSubRecordLang,"textField_mn6vamof");    //系列
            nameLang = UtilMap.getString(projectSubRecordLang,"textField_mn6vamoh");    //语言
            if(PublicUtil.isNull(nameLang)){
                nameLang = "无";
            }
            devNum = UtilMap.getString(projectSubRecordLang,"numberField_mn6vamok");   //研发部订单需求数量
            seriesLangDevNumMap.putIfAbsent(nameSeries + "_" + nameLang, devNum);
        }

        /*
            获取所有配件记录
         */
        List<Map> partsRecordList;    //所有配件记录，旧变量名 -> result
        List<Map> partsTaskSubData = new ArrayList<>();    //配件任务明细数据
        Map<String,List<Map>> partsRecordListBySupplier = new HashMap<>(); // 供应商与采购需求关联数据
        boolean isMultiLang;    //语言区别，旧变量名 -> isLang
        String partsMajorType;  //配件大类，旧变量名 -> type
        Map<String,List<String>> partsConfMapByMajorType; //配件参数信息（某配件大类），旧变量名 -> sonconfs
        List<String> phaseDeliverablesList; //阶段产出物列表
        List<String> partsMajorTypePhaseDeliverables;   //配件大类与产出物列表，旧变量名 -> sonconf
        for(Map projectSubRecordParts : projectSubDataParts){ //遍历【项目台账】子表单【全品类】数据，旧变量名 -> map
            /*
                获取配件大类与产出物列表
             */
            supplier = UtilMap.getString(projectSubRecordParts,"textField_me2f7tvz"); //供应商，旧变量名 -> gysName
            isMultiLang = "是".equals(UtilMap.getString(projectSubRecordParts,"radioField_me2f7tvx"));   //语言区别
            partsMajorType = UtilMap.getString(projectSubRecordParts,"selectField_me2f7tvk");
            partsConfMapByMajorType = partsConfMap.get(partsMajorType);
            partsMajorTypePhaseDeliverables = new ArrayList<>();
            if(partsConfMapByMajorType!=null && !partsConfMapByMajorType.isEmpty()){
                for(String projectPhase : projectPhaseList){ //遍历项目包含阶段
                    if(partsConfMapByMajorType.containsKey(projectPhase)){
                        phaseDeliverablesList = partsConfMapByMajorType.get(projectPhase);
                        for (String phaseDeliverables: phaseDeliverablesList) {
                            partsMajorTypePhaseDeliverables.add(partsMajorType+" / "+phaseDeliverables);
                        }
                    }
                }
            }
            /*
                获取所有配件记录
             */
            partsRecordList = getPartsRecordList(null,orderSubDataLang,projectSubRecordParts,null,isMultiLang,partsMajorTypePhaseDeliverables,null,supplier,projectCode,leadsCode,partsTypeNameCodeMap,seriesLangDevNumMap);
            /*
                按供应商对配件记录进行分组
             */
            if(partsRecordListBySupplier.containsKey(supplier)){
                partsRecordListBySupplier.get(supplier).addAll(partsRecordList);
            }else{
                partsRecordListBySupplier.put(supplier,partsRecordList);
            }
            partsTaskSubData.addAll(partsRecordList);
        }
        log.info("配件任务明细数量="+partsTaskSubData.size());

        /*
            按项目阶段拆解配件任务数据
         */
        Map partsTaskData;  //配件任务数据，旧变量名 -> order
        List<String> partsTaskPhaseList = Arrays.asList("白样", "产前样","大货样", "大货"); //配件任务阶段（不包含包装）列表，旧变量名 -> jdList
        long projectPhasePlanEndTime;   //项目阶段计划结束时间（时间戳）
        List<Map> partsTaskSubDataNew; //配件任务明细数据（新）
        String partsTaskStatus;   //配件任务状态，旧变量名 -> taskStatus
        String partsTaskOrderType;  //订单类型【配件任务表】，旧变量名 -> taskType
        String purchaseType;    //采购类型，旧变量名 -> procuremenType
        Map<String, Object> partsRecordNew;  //配件记录（新），旧变量名 -> copiedMap
        List<Map> supplierBuyerData;  //【供应商跟单员档案】数据，旧变量名 -> gysList
        List<UtilMap.assDetail> supplierBuyerDataAssSupplier;    //【供应商跟单员档案】关联表单【供应商】，旧变量名 -> gys
        String numOfSets;   //工厂采购数量
        int allSupplyNum;   //总采购数量
        BigDecimal unitPrice;   //单价
        BigDecimal subTotal;   //小计金额
        for(String projectPhase : projectPhaseList){ //遍历项目包含阶段，旧变量名 -> jd
            log.info("项目阶段:"+projectPhase);
            if(partsTaskPhaseList.contains(projectPhase)){
                /*
                    获取当前阶段计划结束时间
                 */
                projectPhasePlanEndTime = 0;
                for(Map projectSubRecordPlan : projectSubDataPlan){    //遍历项目计划阶段
                    if(projectPhase.equals(UtilMap.getString(projectSubRecordPlan,"textField_mgu5rm3f"))){   //阶段匹配成功
                        projectPhasePlanEndTime = UtilMap.getLong(projectSubRecordPlan,"dateField_mgu5rm3h");    //计划结束时间，旧变量名 -> planTimestamp
                        log.info("计划结束时间:"+DateUtil.formatDate(new Date(projectPhasePlanEndTime)));
                    }
                }
                for (String keySupplier : partsRecordListBySupplier.keySet()){ //遍历采购需求数据，旧变量名 -> key
                    partsRecordList = partsRecordListBySupplier.get(keySupplier);  //配件记录（按供应商区分），旧变量名 -> arr
                    partsTaskSubDataNew = new ArrayList<>();
                    purchaseType = "";
                    partsTaskStatus = "";
                    partsTaskOrderType = "";
                    for (Map<String, Object> partsRecord : partsRecordList) { //遍历配件记录（按供应商区分），旧变量名 -> map
                        if("大货".equals(projectPhase)){
                            purchaseType ="配件采购";
                            partsTaskStatus ="待排期";
                            partsTaskOrderType ="大货";
                            numOfSets = partsRecord.get("numberField_mifp03el")==null?null:partsRecord.get("numberField_mifp03el").toString();
                            devNum = partsRecord.get("numberField_mmmwu4cg")==null?null:partsRecord.get("numberField_mmmwu4cg").toString();
                            allSupplyNum = 0;
                            if(StringUtils.isNotEmpty(numOfSets)){
                                if(StringUtils.isNotEmpty(devNum)){ //研发部订单需求数量是否填写
                                    allSupplyNum = Integer.parseInt(devNum) + Integer.parseInt(numOfSets);  //计算总采购数量
                                }else{
                                    allSupplyNum = Integer.parseInt(numOfSets); //总采购数量=工厂采购数量
                                }
                            }
                            partsRecordNew = new HashMap<>(partsRecord); // 关键：创建副本
                            partsRecordNew.put("dateField_mizvc5oi", projectPhasePlanEndTime); //考核日期（采购明细）
                            partsRecordNew.put("numberField_mmmwu4ci",0);    //总采购数量（废弃）
                            partsRecordNew.put("numberField_mifp03el",allSupplyNum);   //工厂采购数量
                            //计算小计金额
                            if(partsRecord.get("numberField_me2f7tw0")!=null && StringUtils.isNotEmpty(partsRecord.get("numberField_me2f7tw0").toString().trim())){
                                unitPrice = new BigDecimal(partsRecord.get("numberField_me2f7tw0").toString().trim()); //单价
                                subTotal = unitPrice.multiply(BigDecimal.valueOf(allSupplyNum));
                                partsRecordNew.put("numberField_mifp03ey", subTotal);   //小计金额
                            }
//                            System.out.println("系列："+UtilMap.getString(partsRecordNew,"textField_mpcf6yu2")+"，语言："+UtilMap.getString(partsRecordNew,"textField_mjr129o4")+"，配件名称："+UtilMap.getString(partsRecordNew,"textField_mecmytpr")
//                                    +"，工厂采购数量："+allSupplyNum+"，单价："+partsRecord.get("numberField_me2f7tw0").toString().trim()+"，小计金额："+UtilMap.getString(partsRecordNew,"numberField_mifp03ey"));
                            partsTaskSubDataNew.add(partsRecordNew);
                        } else{
                            if("大货样".equals(projectPhase)){
                                partsTaskStatus ="无需合同";
                            }else{  //白样和产前样
                                partsTaskStatus ="待排期";
                            }
                            purchaseType ="样品任务";
                            partsTaskOrderType ="打样";
                            partsRecordNew = new HashMap<>(partsRecord); // 关键：创建副本
                            partsRecordNew.put("dateField_mizvc5oi", projectPhasePlanEndTime); //考核日期（采购明细）
                            partsRecordNew.put("numberField_mkosp94h", sampleNum);   //客户订单数量
                            partsRecordNew.put("numberField_mmmwu4cg",0);    //研发部订单需求数量
                            partsRecordNew.put("numberField_mmmwu4ci",0);    //总采购数量（废弃）
                            partsRecordNew.put("numberField_mifp03el", sampleNum);   //工厂采购数量
                            partsRecordNew.put("numberField_me2f7tw0", 0);   //单价
                            partsRecordNew.put("numberField_mifp03ey", 0);   //小计金额
                            partsTaskSubDataNew.add(partsRecordNew);
                        }
                    }
                    partsTaskData = UtilMap.map(
                            //"textField_mifp03ew, " +    //TB项目编号
                                    "selectField_mifp03e7, " +  //任务状态
                                    "tableField_mifp03em, " +   //采购明细
                                    "selectField_mkf6qv9b, " +  //采购类型
                                    "dateField_mifp03eb, " +    //计划完成日期
                                    "selectField_ml0l206x, "+   //订单类型
                                    "employeeField_mp6muk63, "+   //业务员
                                    "employeeField_mp6muk64, "+   //业务组长
                                    "employeeField_mp6muk65, "+   //PM
                                    "employeeField_mp6muk66, "+   //QA
                                    "radioField_mp6hn7xp",  //测试使用
                            //tbProjectId,
                            partsTaskStatus,
                            partsTaskSubDataNew,
                            purchaseType,
                            projectPhasePlanEndTime,
                            partsTaskOrderType,
                            ssUserId,
                            ssmUserId,
                            pmUserId,
                            qaUserId,
                            testFlag
                    );
                    partsTaskData.put("associationFormField_mifp03e9",projectDataAssOrder); //项目订单
                    partsTaskData.put("associationFormField_mifp03e8",projectDataAssLeads); // 销售项目
                    partsTaskData.put("textField_mifp03e6",projectName+"-"+keySupplier+"-"+projectPhase);   //任务名称
                    partsTaskData.put("textField_mimwnauk",projectCode);    //项目编号（立项流程）
                    partsTaskData.put("textField_mp6hqggg",projectName);    //项目名称（立项流程）
                    //supplierOrder.put("textField_mizs3841",pMainId);
                    partsTaskData.put("employeeField_mifp03eu",Arrays.asList(supplierBuyerMap.get(keySupplier))); //跟单负责人
                    /*
                        查询供应商与跟单数据
                        【供应商跟单员档案】  FORM-3AB247087A81401F87264BFA74944BE3R086
                     */
                    supplierBuyerData = (List<Map>) ydClient.queryData(
                            YDParam.builder()
                                    .formUuid(EastarParam.YD_FORMUUID_GYS_YW)
                                    .searchCondition(
                                            JSONObject.toJSONString(
                                                    Arrays.asList(
                                                            new YDSearch(
                                                                    "textField_mec6lku3",   //供应商简称
                                                                    keySupplier,
                                                                    "供应商简称",
                                                                    YDSearch.Type.TEXT_FIELD,
                                                                    YDSearch.Operator.EQ
                                                            )
                                                    )
                                            )
                                    ).build(),
                            YDConf.FORM_QUERY.retrieve_list
                    ).getData();
                    if(supplierBuyerData!=null && supplierBuyerData.size()>0){
                        supplierBuyerDataAssSupplier
                                = UtilMap.getAssFieldValue(
                                        UtilMap.getMap(supplierBuyerData.get(0),"formData"),
                                        "associationFormField_mec6lku4_id"  //供应商
                                  );
                        partsTaskData.put("associationFormField_mifp03ea",supplierBuyerDataAssSupplier); //供应商
                        partsTaskData.put("textField_mpql81b5",leadsCode);    // 项目编号
                        partsTaskData.put("textField_mifp03ez",supplierBuyerDataAssSupplier.get(0).subTitle);    // 供应商编号
                    }
                    partsTaskData.put("textField_mmikzhlb",projectPhase); //里程碑
                    /*
                        保存配件任务数据（不含包装）
                        【配件任务表】 FORM-B9CBFB34DB3249C483415EF641202AC199J9
                     */
//                    log.info("保存配件任务数据（"+projectPhase+"）:"+ JSONObject.toJSONString(partsTaskData));
                    ydClient.operateData(
                            YDParam.builder()
                                    .formUuid(EastarParam.YD_FORMUUID_CGTASK)
                                    .formDataJson(JSONObject.toJSONString(partsTaskData))
                                    .build(),
                            YDConf.FORM_OPERATION.create
                    );
                }
            }
        }

        /*
            生成包装任务（打样不需要生成包装）
         */
        if("大货".equals(projectOrderType)){
            savePartsPackTaskData(null, orderSubDataLang, projectData, projectName, projectCode, leadsCode, projectDataAssOrder, supplierBuyerMap, seriesLangDevNumMap, projectSubDataPlan);
        }


        if("是".equals(devNumFlag)){  //研发部需要留样
            /*
                更新【销售订单】子表单【语言版本 - 数量拆分】的总套数
             */
            List<Map> orderSubDataLangNew = new ArrayList<>();
            for(Map orderSubRecordLang : orderSubDataLang){  //遍历子表单记录
                nameSeries = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wa");    // 系列【语言版本 - 数量拆分】
                nameLang = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wb"); // 语言【语言版本 - 数量拆分】
                numOfSetsSeries = UtilMap.getInt(orderSubRecordLang,"numberField_meqqj4wd");    // 套数【语言版本 - 数量拆分】
                numOfSetsAll = 0;
                if(PublicUtil.isNull(nameLang)){
                    devNum = seriesLangDevNumMap.get(nameSeries+"_无");   //研发部订单需求数量
                }else{
                    devNum = seriesLangDevNumMap.get(nameSeries+"_"+nameLang);   //研发部订单需求数量
                }
                if(StringUtils.isNotEmpty(devNum)){
                    numOfSetsAll = numOfSetsSeries + Integer.parseInt(devNum);    // 总套数【语言版本 - 数量拆分】，总套数=套数+研发部订单数量，立项完成自动更新总套数
                }
                orderSubRecordLang.put("numberField_mmtymctd",numOfSetsAll);
                orderSubDataLangNew.add(orderSubRecordLang);
            }
//            log.info("更新【销售订单】数据:"+ JSONObject.toJSONString(orderSubDataLangNew));
            ydClient.operateData(
                    YDParam.builder()
                            .formInstId(orderId)
                            .updateFormDataJson(
                                    JSONObject.toJSONString(UtilMap.map("tableField_meqqj4we",orderSubDataLangNew))
                            ).build(),
                    YDConf.FORM_OPERATION.update
            );
        }

        /*
            新增【PSS系列】记录
         */
        Map<String,String> pssSeriesMap = new HashMap<>();
        for(Map projectSubRecordLang : projectSubDataLang){
            nameSeries = UtilMap.getString(projectSubRecordLang,"textField_mn6vamof");    //系列
            codeSeries = UtilMap.getString(projectSubRecordLang,"textField_mn6vamog");    //系列编号
            if (!pssSeriesMap.containsKey(nameSeries)) {
                pssSeriesMap.put(nameSeries, codeSeries);
            }
        }
        Map projectPssSeriesMap;
        for(String seriesName : pssSeriesMap.keySet()){
            projectPssSeriesMap = UtilMap.map(
                    "textField_mpdet3xr, " +  //项目编号（立项流程）
                            "textField_mpdet3xs, " +   //系列
                            "textField_mpdey1no",  //系列编号
                    projectCode,
                    seriesName,
                    pssSeriesMap.get(seriesName)
            );
//            log.info("新增【PSS系列】记录:"+ JSONObject.toJSONString(projectPssSeriesMap));
            ydClient.operateData(
                    YDParam.builder()
                            .formUuid(EastarParam.YD_FORMUUID_PSS_SERIES)
                            .formDataJson(JSONObject.toJSONString(projectPssSeriesMap))
                            .build(),
                    YDConf.FORM_OPERATION.create
            );
        }

        log.info("【项目台账】→【采购任务】数据流转结束");
        return Collections.emptyMap();
    }


    /**
     * 获取所有配件记录
     */
    private List<Map> getPartsRecordList(
            Map taskMap,    //TB相关，无用
            List<Map> orderSubDataLang, //销售订单子表单记录，【语言版本 - 数量拆分】明细数据，旧变量名 -> orderConf
            Map projectSubRecordParts,  //【项目台账】子表单【全品类】某一行记录，旧变量名 -> cgDetail
            List<Map> customfields, //TB相关，无用
            boolean isMultiLang, //是否存在多种语言版本，旧变量名 -> isLang
            List<String> partsPhaseDeliverables,   //配件状态明细（按配件大类分组），旧变量名 -> sonConf
            String sonScenariofieldconfigId,    //TB相关，无用
            String supplier,    //供应商，旧变量名 -> gysName
            String projectCode, // 项目编号（立项流程），旧变量名 -> pId
            String leadsCode, // 线索编码，旧变量名 -> pMainId
            Map partsTypeNameCodeMap,    //品类名称与配件编号（这里的配件编号应该是品类编码）映射，旧变量名 -> skuIdMap
            Map<String,String> seriesLangDevNumMap  //系列语言与研发部订单需求数量映射数据
    ){
        List<Map> partsRecordList = new ArrayList<>();    //所有配件记录
        String nameSeries;  //系列，旧变量名 -> confSeries
        String nameLang;    //语言
        String partsTypeCode;   //配件类型编码（来源于【品类表】的“配件编号”），旧变量名 -> skuId
        String partsTypeName;   //配件类型名称（来源于【品类表】的“品类名称”）
        String docSN; //文档序号，旧变量名 -> reportId
        String skuSN; //SKU编号，旧变量名 -> sku
        String numOfSets;   //套数【语言版本 - 数量拆分】或套数【系列套数】，旧变量名 -> value
        String devNum;  //研发部订单需求数量，旧变量名 -> rdNum
        String partsName;   //配件名称
        Map partsRecord;  //配件记录，来源于【项目台账】子表单【全品类】某一行记录，旧变量名 -> recod
        for(Map orderSubRecordLang : orderSubDataLang){    //遍历子表单记录，旧变量名 -> map
//            nameSeries = UtilMap.getString_first(
//                    orderSubRecordLang,
//                    "textField_meqqj4wa",   //系列【语言版本 - 数量拆分】
//                    "textField_mesc7nvf"    //系列【系列套数】
//            ); // 系列
            nameSeries = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wa");    //系列【语言版本 - 数量拆分】
            if(!UtilMap.getString(projectSubRecordParts,"selectField_me2f7tw4").equals(nameSeries)){
                // 系列【全品类】与系列【语言版本 - 数量拆分】
                continue;
            }
            partsTypeName = UtilMap.getString(projectSubRecordParts,"selectField_mizsccds");    //配件类型
            partsTypeCode = String.valueOf(partsTypeNameCodeMap.get(partsTypeName));
            partsTypeCode = PublicUtil.isNull(partsTypeCode) ? "000":partsTypeCode;
            docSN = UtilMap.getString(projectSubRecordParts,"textField_me2f7tvn");
            skuSN = "2"
                    + partsTypeCode //配件类型
                    + UtilMap.getString(orderSubRecordLang,"textField_mizmmf8h")   //系列编号【语言版本 - 数量拆分】
                    + docSN.substring(docSN.length()-3);  // 文档编号（后3位）
            nameLang = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wb"); // 语言【语言版本 - 数量拆分】，旧变量名 -> lang
            if(PublicUtil.isNull(nameLang)){
                devNum = seriesLangDevNumMap.get(nameSeries+"_无");   //研发部订单需求数量
            }else{
                devNum = seriesLangDevNumMap.get(nameSeries+"_"+nameLang);   //研发部订单需求数量
            }
            if(isMultiLang){ // 是否存在多种语言版本
                skuSN = skuSN + UtilMap.getString(orderSubRecordLang,"textField_mizmmf8i"); // sku+语言编号
            }else{
                if(PublicUtil.isNull(nameLang)){
                    nameLang = "不区分";
                    skuSN = skuSN+"AL"; // sku 不区分语言
                }else{
                    skuSN = skuSN + UtilMap.getString(orderSubRecordLang,"textField_mizmmf8i"); // sku+语言编号
                }
            }
            skuSN = skuSN + leadsCode.substring(leadsCode.length()-10); // sku+项目号
//            numOfSets = UtilMap.getString_first(
//                    orderSubRecordLang,
//                    "numberField_meqqj4wd", // 套数【语言版本 - 数量拆分】
//                    "numberField_mesc7nvi"  // 套数【系列套数】
//            ); // 数量
            numOfSets = UtilMap.getString(orderSubRecordLang,"numberField_meqqj4wd");    // 套数【语言版本 - 数量拆分】
            partsName = UtilMap.getString(projectSubRecordParts,"textField_me2f7tvo");  //配件名称
            /*
                复制【项目台账】子表单【全品类】记录为配件记录，并补充部分字段
             */
            partsRecord = new HashMap(projectSubRecordParts);
            partsRecord.putAll(
                    UtilMap.map(
                            "textField_mecmytpr, " + //配件名称
                                    "textField_mq4we7wq, " + //配件大类
                                    "textField_mpcfcy7f, " + //配件类型
                                    "textField_mecmytps, " + //TB任务编号
                                    //"textField_mecmytpt," +
                                    "numberField_mkosp94h, " +   //客户订单数量
                                    "numberField_mmmwu4cg, " +   //研发部订单需求数量
                                    "numberField_mifp03el, " +   //工厂采购数量
                                    "textField_mifp03eo, " + //SKU编号
                                    "textField_miib17jx, " + //项目编号
                                    "textField_mizvc5oj, " + //任务表明细实例标识
                                    "textField_mpcf6yu2, " + //系列
                                    "textField_mjr129o4, " + //语言
                                    "radioField_mpm9k87c, " + //配件共用信息
                                    "numberField_mq4we7wr, " + //厚度
                                    "textField_mizu4cxk, " + //品质注意点
                                    "imageField_mpw90w7y, " + //图片
                                    "numberField_me2f7tw0", //单价
                            partsName,
                            UtilMap.getString(projectSubRecordParts,"selectField_me2f7tvk"),
                            UtilMap.getString(projectSubRecordParts,"selectField_mizsccds"),
                            "~",
                            //"未开始",
                            numOfSets,
                            devNum,
                            numOfSets,  //此时工厂采购数量未包含研发部订单需求数量
                            skuSN,
                            projectCode,
                            "~",
                            UtilMap.getString(projectSubRecordParts,"selectField_me2f7tw4"),
                            nameLang,
                            UtilMap.getString(projectSubRecordParts,"radioField_me2f7tvw"), //配件共用信息
                            UtilMap.getString(projectSubRecordParts,"numberField_mq4t39px"), //厚度
                            UtilMap.getString(projectSubRecordParts,"textField_mq6bsu17"), //品质注意点
                            UtilMap.getString(projectSubRecordParts,"imageField_me2f7tvv"), //图片
                            UtilMap.getString(projectSubRecordParts,"numberField_mpqc5tmf") //大货供应商单价
                    )
            );
            partsRecordList.add(partsRecord);
        }


        return partsRecordList;
    }


    /**
     * 保存配件任务数据（包装）
     */
    private List<Map> savePartsPackTaskData(
            String tbProjectId, //TB相关，无用
            List <Map> orderSubDataLang,   //【销售订单】子表单【语言版本 - 数量拆分】数据，旧变量名 -> orderLangConf
            Map projectData,   //【项目台账】数据，旧变量名 -> data
            String projectName,   // 项目名称，旧变量名 -> pName
            String projectCode, // 项目编号（立项流程），旧变量名 -> pId
            String leadsCode, // 项目编号，旧变量名 -> pMainId
            List projectDataAssOrder,  //【项目台账】关联表单【销售订单】，旧变量名 -> projectOrder
            Map supplierBuyerMap,  //供应商与采购跟单userid映射，旧变量名 -> mchDDIdMap
            Map<String,String> seriesDevNumMap,  //系列与研发部订单需求数量映射数据
            List<Map> projectSubDataPlan //【项目台账】子表单【项目计划】
    ) {
        Map<String, List<Map>> partsRecordListBySupplier = new HashMap<>();  // 供应商与采购需求关联数据，旧变量名 -> packOrderData
        Map partsRecord;   //配件记录，旧变量名 -> packTask
        String supplier;    //供应商
        String numOfSets;   //套数，旧变量名 -> setsValue
        String nameSeries;  //系列
        String nameLang;    //语言
        String devNum;  //研发部订单需求数量
        int allSupplyNum;   //总采购数量

        log.info("项目阶段:包装");
        boolean packTaskFlag = false;   //是否有包装阶段
        long projectPhasePlanEndTime = 0;
        for(Map projectSubRecordPlan : projectSubDataPlan){    //遍历项目计划阶段
            if("包装".equals(UtilMap.getString(projectSubRecordPlan,"textField_mgu5rm3f"))){   //阶段匹配成功
                projectPhasePlanEndTime = UtilMap.getLong(projectSubRecordPlan,"dateField_mgu5rm3h");    //计划结束时间，旧变量名 -> planTimestamp
                log.info("计划结束时间:"+DateUtil.formatDate(new Date(projectPhasePlanEndTime)));
                packTaskFlag = true;
            }
        }

        if(!packTaskFlag){
            //没有包装阶段
            return null;
        }

        for (Map orderSubRecordLang : orderSubDataLang) { //遍历子表单，旧变量名 -> orderMap
            supplier = UtilMap.getString(orderSubRecordLang, "textField_mkp7yv76"); //供应商
            numOfSets = UtilMap.getString(orderSubRecordLang, "numberField_meqqj4wd");  //套数
            nameSeries = UtilMap.getString(orderSubRecordLang, "textField_meqqj4wa");   //系列
            nameLang = UtilMap.getString(orderSubRecordLang,"textField_meqqj4wb"); // 语言【语言版本 - 数量拆分】
            if(PublicUtil.isNull(nameLang)){
                devNum = seriesDevNumMap.get(nameSeries+"_无");
            }else{
                devNum = seriesDevNumMap.get(nameSeries+"_"+nameLang);
            }
            allSupplyNum = 0;
            if(StringUtils.isNotEmpty(numOfSets)){
                if(StringUtils.isNotEmpty(devNum)){ //研发部订单需求数量是否填写
                    allSupplyNum = Integer.parseInt(devNum) + Integer.parseInt(numOfSets);  //计算总采购数量
                }else{
                    allSupplyNum = Integer.parseInt(numOfSets);  //总采购数量=工厂采购数量
                }
            }

            partsRecord = UtilMap.map(
                    "textField_mecmytpr, " +    //配件名称
                            "textField_mifp03eo, " +    //SKU编号
                            "textField_mjr129o4, " +    //语言
                            "textField_mpcf6yu2, " +  //系列
                            "dateField_mizvc5oi, " +  //考核日期（采购明细）
                            "numberField_mkosp94h, " +  //客户订单数量
                            "numberField_mmmwu4cg, " +  //研发部订单需求数量
                            "numberField_mmmwu4ci, " +  //总采购数量（废弃）
                            "numberField_mifp03el, "+ //工厂采购数量
                            "numberField_me2f7tw0, "+ //单价
                            "numberField_mifp03ey", //小计金额
                    UtilMap.getString(orderSubRecordLang, "textField_mizmmf8k"),    //成品名称
                    UtilMap.getString(orderSubRecordLang, "textField_mizmmf8j"),    //成品编号
                    UtilMap.getString(orderSubRecordLang, "textField_meqqj4wb"),    //语言
                    nameSeries,    //系列
                    projectPhasePlanEndTime,   //考核日期（采购明细）
                    numOfSets,
                    devNum, //研发部订单需求数量
                    0, //总采购数量（废弃）
                    allSupplyNum,    //工厂采购数量
                    0,  //单价
                    0 //小计金额
            );


            partsRecordListBySupplier.computeIfAbsent(supplier, k -> new ArrayList<>()).add(partsRecord);
        }
        List<String> ssUserId = (List<String>) UtilMap.getList(projectData, "employeeField_me2hyld9_id");  // 业务员 userid
        List<String> ssmUserId = (List<String>) UtilMap.getList(projectData, "employeeField_mp6mn6je_id");  // 业务组长 userid
        List<String> pmUserId = (List<String>) UtilMap.getList(projectData, "employeeField_me2hyld8_id");  // PM userid
        List<String> qaUserId = (List<String>) UtilMap.getList(projectData, "employeeField_me9n24ka_id");  // QA userid
        String testFlag = UtilMap.getString(projectData,"radioField_mp4t9q57");  //测试使用
        List<Map> partsRecordList;  //配件记录（按供应商区分），旧变量名 -> packdetails
        Map partsTaskData;  //配件任务数据，旧变量名 -> packTaskorder
        List<Map> supplierBuyerData;  //【跟单-供应商对应表】数据，旧变量名 -> gysList
        List<UtilMap.assDetail> supplierBuyerDataAssSupplier;    //【跟单-供应商对应表】关联表单【供应商】，旧变量名 -> gys
        for (String keySupplier : partsRecordListBySupplier.keySet()){  //遍历供应商与采购需求关联数据，旧变量名 -> key
            partsRecordList = partsRecordListBySupplier.get(keySupplier);
            partsTaskData = UtilMap.map(
//                    "textField_mifp03ew, " +    //TB项目编号
                            "selectField_mifp03e7, " +  //任务状态
                            "tableField_mifp03em, " +   //采购明细
                            "selectField_mkf6qv9b, " +  //采购类型
                            "selectField_ml0l206x, "+   //订单类型
                            "employeeField_mp6muk63, "+   //业务员
                            "employeeField_mp6muk64, "+   //业务组长
                            "employeeField_mp6muk65, "+   //PM
                            "employeeField_mp6muk66, "+   //QA
                            "dateField_mifp03eb, " +  //考核日期
                            "radioField_mp6hn7xp",  //测试使用
//                    tbProjectId,
                    "待排期",
                    partsRecordList,
                    "成品包装",
                    "大货",
                    ssUserId,
                    ssmUserId,
                    pmUserId,
                    qaUserId,
                    projectPhasePlanEndTime,
                    testFlag
            );
            partsTaskData.put("associationFormField_mifp03e9",projectDataAssOrder); //项目订单
            partsTaskData.put("associationFormField_mifp03e8",
                    UtilMap.getAssFieldValue(projectData,"associationFormField_mdy7w1wn_id")
            );  // 销售项目
            partsTaskData.put("textField_mifp03e6",projectName+"-"+keySupplier+"-包装");  //任务名称
            partsTaskData.put("textField_mimwnauk",projectCode);    //项目编号（立项流程）
            partsTaskData.put("textField_mp6hqggg",projectName);    //项目名称（立项流程）
//            partsTaskData.put("textField_mizs3841",leadsCode);
            partsTaskData.put("employeeField_mifp03eu",Arrays.asList(supplierBuyerMap.get(keySupplier)));   //跟单负责人
            supplierBuyerData = (List<Map>) ydClient.queryData(
                    YDParam.builder()
                            .formUuid(EastarParam.YD_FORMUUID_GYS_YW)
                            .searchCondition(
                                    JSONObject.toJSONString(
                                            Arrays.asList(
                                                    new YDSearch(
                                                            "textField_mec6lku3",  //"供应商简称"
                                                            keySupplier,
                                                            "供应商简称",
                                                            YDSearch.Type.TEXT_FIELD,
                                                            YDSearch.Operator.EQ
                                                    )
                                            )
                                    )
                            )
                            .build(),
                    YDConf.FORM_QUERY.retrieve_list
            ).getData();
            if(supplierBuyerData!=null && supplierBuyerData.size()>0){
                supplierBuyerDataAssSupplier
                        = UtilMap.getAssFieldValue(
                                UtilMap.getMap(supplierBuyerData.get(0),"formData"),
                        "associationFormField_mec6lku4_id"
                        );
                partsTaskData.put("associationFormField_mifp03ea",supplierBuyerDataAssSupplier);    //供应商
                partsTaskData.put("textField_mpql81b5",leadsCode); //项目编号
                partsTaskData.put("textField_mifp03ez",supplierBuyerDataAssSupplier.get(0).subTitle); // 供应商编号
            }
            partsTaskData.put("textField_mmikzhlb","包装"); //里程碑
//            System.out.println("保存配件任务数据（包装）:"+ JSONObject.toJSONString(partsTaskData));
            ydClient.operateData(
                    YDParam.builder()
                            .formUuid(EastarParam.YD_FORMUUID_CGTASK)
                            .formDataJson(JSONObject.toJSONString(partsTaskData))
                            .build(),
                    YDConf.FORM_OPERATION.create
            );
        }

        return null;
    }

    @Override
    public List<Map> queryLtcAllBusinessUserData() throws Exception {
        /*
            参数定义
         */
        List<Map> businessUserData = new ArrayList<>(); // 业务人员数据
        Map<String,String> businessUserRecord;  //业务人员记录
        YDSearch ydSearch; //检索条件（单个）
        String searchCondition; //检索条件
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        JSONArray businessUserIdJSONArray;  //业务员userId（未解析）
        String userId;  //用户userId
        JSONArray businessLeaderUserIdJSONArray;  //业务组长userId（未解析）
        String businessLeaderUserId;  //业务组长userId

        /*
            初始化参数值
         */
        ydSearch = new YDSearch(
                "radioField_mn48qynm",
                "在职",
                "在职情况",
                YDSearch.Type.RADIO_FIELD,
                YDSearch.Operator.EQ
        );
        searchCondition = JSONObject.toJSONString(Arrays.asList(ydSearch));
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_BUSINESS_USER);
        ydParamBuilder = ydParamBuilder.searchCondition(searchCondition);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        userId = "";
        businessLeaderUserId = "";
        for (Map record : allRecords){
            businessUserRecord = new HashMap<>();
            //获取表单实例ID
            formInstId = String.valueOf(record.get("formInstanceId"));
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(record.get("formData")));
            /*
                获取成员数据
             */
            if(fields.get("employeeField_mdfaff58_id") != null){
                businessUserIdJSONArray = fields.getJSONArray("employeeField_mdfaff58_id");
                if(!businessUserIdJSONArray.isEmpty()){
                    userId = String.valueOf(businessUserIdJSONArray.get(0));
                }
            }
            /*
                获取业务组长数据
             */
            if(fields.get("employeeField_mektcwc6_id") != null){
                businessLeaderUserIdJSONArray = fields.getJSONArray("employeeField_mektcwc6_id");
                if(!businessLeaderUserIdJSONArray.isEmpty()){
                    businessLeaderUserId = String.valueOf(businessLeaderUserIdJSONArray.get(0));
                }
            }
            if(!formInstId.isEmpty() && !userId.isEmpty()){
                businessUserRecord.put("formInstId",formInstId);
                businessUserRecord.put("userId",userId);
                businessUserRecord.put("businessLeaderUserId",businessLeaderUserId);
                businessUserData.add(businessUserRecord);
            }
        }

        return businessUserData;
    }

    @Override
    public void setLtcBusinessUserLeave(String formInstId) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        updateFormDataJson = JSONObject.toJSONString(UtilMap.map("radioField_mn48qynm","已离职"));  //在职情况

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public List<Map> queryLtcAllCustomerData() throws Exception {
        /*
            参数定义
         */
        List<Map> ltcCustomerData = new ArrayList<>();
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        Map customerRecord;  //客户记录
        String customerName;
        String customerCode;
        JSONArray businessUserIdJSONArray;  //业务员userId
        String userId;  //用户userId
        String userIdText;

        /*
            初始化参数值
         */
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_CUSTOMER);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map ltcCustomerRecord : allRecords){
            userId = "";
            customerName = "";
            customerCode = "";
            //获取表单实例ID
            formInstId = String.valueOf(ltcCustomerRecord.get("formInstanceId"));
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(ltcCustomerRecord.get("formData")));
            /*
                获取成员数据
             */
            businessUserIdJSONArray = null;
            if(fields.get("employeeField_lqanqe6n_id") != null){
                businessUserIdJSONArray = fields.getJSONArray("employeeField_lqanqe6n_id");
                if(!businessUserIdJSONArray.isEmpty()){
                    userId = String.valueOf(businessUserIdJSONArray.get(0));
                }
            }
            userIdText = String.valueOf(ltcCustomerRecord.get("textField_mnchujji"));

            customerName = fields.getString("textField_lqanqe6j");
            customerCode = fields.getString("serialNumberField_lqanqe6i");

            //生成客户数据
            customerRecord = UtilMap.map(
                    "formInstId, customerName, customerCode, userId, userIdText, customerLevel, customerPotentialLevel, newOrOld, testUseFlag, aiTableId",
                    formInstId, //表单实例ID
                    customerName, //客户公司名（英文名）
                    customerCode,   //客户编号
                    userId,  //业务
                    userIdText,
                    fields.getString("selectField_mcsoft5i"),    //客户当前分级
                    fields.getString("selectField_mhsvnqsv"),    //客户潜在等级
                    fields.getString("radioField_md6q7ox8"),    //新老客户
                    fields.getString("radioField_mnpdkss9"),    //测试使用
                    fields.getString("textField_mno9nwip")  //AI表格映射ID
            );
            ltcCustomerData.add(customerRecord);
        }

        return ltcCustomerData;
    }

    @Override
    public List<Map> queryLtcAllSaleProjectData() throws Exception {
        /*
            参数定义
         */
        List<Map> saleProjectData = new ArrayList<>();
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        Map saleProjectRecord;  //销售项目记录

        /*
            初始化参数值
         */
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_SALE_PROJECT);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map ltcSaleProjectRecord : allRecords){
            //获取表单实例ID
            formInstId = String.valueOf(ltcSaleProjectRecord.get("formInstanceId"));
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(ltcSaleProjectRecord.get("formData")));

            saleProjectRecord = UtilMap.map(
                    "formInstId, projectCode, projectName, piCode, aiTableId",
                    formInstId, //表单实例ID
                    fields.getString("serialNumberField_mdf997w0"), //项目编号
                    fields.getString("textField_mdf997vz"), //项目名称
                    fields.getString("textField_mhlrjdz2"), //原系统PI号
                    fields.getString("textField_mno9p0lf")  //AI表格映射ID
            );

            saleProjectData.add(saleProjectRecord);

        }

        return saleProjectData;
    }

    @Override
    public List<Map> queryLtcSaleProjectData(Map params) throws Exception {
        /*
            参数定义
         */
        List<Map> saleProjectData = new ArrayList<>();
        List<YDSearch> ydSearchList = new ArrayList<>(); //检索条件（多个）
        YDSearch ydSearch; //检索条件（单个）
        String searchCondition = null; //检索条件
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        Map saleProjectRecord;  //销售项目记录

        /*
            初始化参数值
         */
        if(params.containsKey("piCodePrefix")){
            ydSearch = new YDSearch(
                    "textField_mhlrjdz2",
                    params.get("piCodePrefix").toString(),
                    "原系统PI号",
                    YDSearch.Type.TEXT_FIELD,
                    YDSearch.Operator.LIKE
            );
            ydSearchList.add(ydSearch);
            searchCondition = JSONObject.toJSONString(ydSearchList);
        }

        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_SALE_PROJECT);
        if(searchCondition != null){
            ydParamBuilder = ydParamBuilder.searchCondition(searchCondition);
        }


        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }



        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map ltcSaleProjectRecord : allRecords){
            //获取表单实例ID
            formInstId = String.valueOf(ltcSaleProjectRecord.get("formInstanceId"));
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(ltcSaleProjectRecord.get("formData")));

            saleProjectRecord = UtilMap.map(
                    "formInstId, projectCode, projectName, projectStage, customer, piCode, aiTableId",
                    formInstId, //表单实例ID
                    fields.getString("serialNumberField_mdf997w0"), //项目编号
                    fields.getString("textField_mdf997vz"), //项目名称
                    fields.getString("selectField_mdf997wp"), //整体项目阶段
                    fields.getString("associationFormField_mdf997wc_id"), //客户
                    fields.getString("textField_mhlrjdz2"), //原系统PI号
                    fields.getString("textField_mno9p0lf")  //AI表格映射ID
            );
            saleProjectData.add(saleProjectRecord);

        }

        return saleProjectData;
    }

    @Override
    public List<Map> queryLtcNotFollowedCustomerData(List ydFilters) throws Exception {
        /*
            参数定义
         */
        List<Map> ltcCustomerData = new ArrayList<>();
        String searchCondition; //检索条件
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        Map customerRecord;  //客户记录
        String customerCode;    //客户编号
        String customerName;    //客户名称
        JSONArray businessUserIdJSONArray;  //业务员字段值
        String userId;  //业务员userId


        /*
            初始化参数值
         */
        searchCondition = JSONObject.toJSONString(ydFilters);
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_CUSTOMER);
        ydParamBuilder = ydParamBuilder.searchCondition(searchCondition);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map ltcCustomerRecord : allRecords){
            userId = "";

            //获取表单实例ID
            formInstId = String.valueOf(ltcCustomerRecord.get("formInstanceId"));

            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(ltcCustomerRecord.get("formData")));

            customerCode = fields.getString("serialNumberField_lqanqe6i");
            customerName = fields.getString("textField_lqanqe6j");

            /*
                获取成员数据
             */
            if(fields.get("employeeField_lqanqe6n_id") != null){
                businessUserIdJSONArray = fields.getJSONArray("employeeField_lqanqe6n_id");
                if(!businessUserIdJSONArray.isEmpty()){
                    userId = String.valueOf(businessUserIdJSONArray.get(0));
                }
            }

            //生成客户数据
            customerRecord = UtilMap.map(
                    "formInstId, customerCode, customerName, userId",
                    formInstId, //表单实例ID
                    customerCode, //客户编号
                    customerName, //客户公司名（英文名）
                    userId  //业务员userId
            );
            ltcCustomerData.add(customerRecord);
        }

        return ltcCustomerData;
    }

    @Override
    public List<Map> queryLtcCustomerEstablishContactData() throws Exception {
        /*
            参数定义
         */
        List<Map> establishContactData = new ArrayList<>();
        YDSearch ydSearch; //检索条件（单个）
        String searchCondition; //检索条件
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        Map establishContactRecord;  //客户建联跟进记录
        String customerCode;    //客户编号
        JSONArray businessUserIdJSONArray;  //跟进人字段值
        String userId;    //业务员userId

        /*
            初始化参数值
         */
        ydSearch = new YDSearch(
                "radioField_mo2p26sg",
                "是",
                "是否已建立联系",
                YDSearch.Type.RADIO_FIELD,
                YDSearch.Operator.EQ
        );
        searchCondition = JSONObject.toJSONString(Arrays.asList(ydSearch));
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_CUSTOMER_CONTACT);
        ydParamBuilder = ydParamBuilder.searchCondition(searchCondition);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }


        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map record : allRecords){
            customerCode = "";
            userId = "";

            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(record.get("formData")));

            //获取客户编号
            customerCode = fields.getString("textField_lqgni3ps");

            /*
                获取业务员userId
             */
            if(fields.get("employeeField_lqbo4rw3_id") != null){
                businessUserIdJSONArray = fields.getJSONArray("employeeField_lqbo4rw3_id");
                if(!businessUserIdJSONArray.isEmpty()){
                    userId = String.valueOf(businessUserIdJSONArray.get(0));
                }
            }

            //添加客户建联跟进记录
            establishContactRecord = UtilMap.map(
                    "customerCode, userId",
                    customerCode, //客户编号
                    userId  //业务员userId
            );
            establishContactData.add(establishContactRecord);
        }

        return establishContactData;
    }

    @Override
    public List<Map> queryLtcRFQData() throws Exception {
        /*
            参数定义
         */
        List<Map> rfqData = new ArrayList<>();  //询价与报价数据
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        Map rfqRecord;  //询价与报价记录
        String projectCode; //项目编号
        Long getRfqDate;  //询价时间

        /*
            初始化参数值
         */
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_RFQ);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map record : allRecords){
            projectCode = "";
            getRfqDate = null;

            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(record.get("formData")));

            //获取项目编号
            projectCode = fields.getString("textField_mdpdyde2");

            //获取询价时间
            getRfqDate = fields.getLong("dateField_mdpdyddc");


            //添加客户建联跟进记录
            rfqRecord = UtilMap.map(
                    "projectCode, getRfqDate",
                    projectCode, //项目编号
                    getRfqDate  //询价时间
            );
            rfqData.add(rfqRecord);
        }

        return rfqData;
    }

    @Override
    public String queryProjectCode(String formInstId) throws Exception {
        Map leadsData = ydClient.queryData(
                YDParam.builder().formInstId(formInstId).build(),
                YDConf.FORM_QUERY.retrieve_id
        ).getFormData();
        return UtilMap.getString(leadsData,"serialNumberField_mdf997w0");   //项目编号
    }

    @Override
    public void updateLtcCustomerTestFlag(String formInstId) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        updateFormDataJson = JSONObject.toJSONString(UtilMap.map("radioField_mnpdkss9","是"));  //测试使用

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo(String formInstId, String customerName, String businessUserId, String seaType, String testUseFlag) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "textField_lqanqe6j, employeeField_lqanqe6n, radioField_md6q7oxa, radioField_mnpdkss9",
                customerName,
                businessUserId!=null?new String[]{businessUserId}:new String[]{},
                seaType,
                testUseFlag
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo2(String formInstId, String customerName, String businessUserId, String seaType, String newOrOld, String testUseFlag) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "textField_lqanqe6j, employeeField_lqanqe6n, radioField_md6q7oxa, radioField_md6q7ox8, radioField_mnpdkss9",
                customerName,
                businessUserId!=null?new String[]{businessUserId}:new String[]{},
                seaType,
                newOrOld,
                testUseFlag
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo3(String formInstId, String customerNameUpperCase, String businessUserId, String businessLeaderUserId, String isBigCustomer) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "textField_meks6pjp, textField_mnchujji, employeeField_lqx3act6, radioField_mo0xhmnw",
                customerNameUpperCase,
                businessUserId,
                businessLeaderUserId!=null?new String[]{businessLeaderUserId}:new String[]{},
                isBigCustomer
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo4(String formInstId, String businessUserId, String businessName, String businessLeaderUserId, String businessDepartment) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "textField_mnchujji, textField_lxa0ko5h, employeeField_lqx3act6, departmentSelectField_lympbaya",
                businessUserId,
                businessName,
                businessLeaderUserId!=null?new String[]{businessLeaderUserId}:new String[]{},
                businessDepartment!=null?new String[]{businessDepartment}:new String[]{}
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo5(String formInstId, String customerLevel1, String customerLevel2, String customerLevel3, String aiTableId) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "selectField_mcsoft5i, selectField_mhsvnqsv, selectField_mfkshib3, textField_mno9nwip",
                customerLevel1,
                customerLevel2,
                customerLevel3,
                aiTableId
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo6(String formInstId, String customerLevel1, String customerLevel2, String newOrOld, String aiTableId) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "selectField_mcsoft5i, selectField_mhsvnqsv, radioField_md6q7ox8, textField_mno9nwip",
                customerLevel1,
                customerLevel2,
                newOrOld,
                aiTableId
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo7(String formInstId, String customerLevel, String customerPotentialLevel) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "selectField_mcsoft5i, selectField_mhsvnqsv",
                customerLevel,
                customerPotentialLevel
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcCustomerBasicInfo8(String formInstId, long privateSeaTime, long lastContactTime) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "dateField_moxzc25f, dateField_l3tw3kfn",
                privateSeaTime,
                lastContactTime
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updatePreviousBusinessUser(String formInstId, String previousBusinessUserId, String previousBusinessGroup) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        Map updateFormData = UtilMap.map(
                "employeeField_mdo82twa, selectField_moyb4zx2, radioField_md6q7oxa, employeeField_lqanqe6n, employeeField_lqx3act6, selectField_moy9v8ve, textField_mnchujji, textField_lxa0ko5h",
                previousBusinessUserId!=null?new String[]{previousBusinessUserId}:new String[]{},   //前跟进人员
                previousBusinessGroup,  //前跟进团队
                "公",    //公海/私海
                new String[]{}, //业务员
                new String[]{}, //业务组长
                "", //业务小组
                "", //业务员userId
                ""  //业务员name
        );
        updateFormDataJson = JSONObject.toJSONString(updateFormData);
        System.out.println(updateFormDataJson);

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateCustomerRelatedAitableId(String formInstId, String aitableId) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        updateFormDataJson = JSONObject.toJSONString(UtilMap.map("textField_mno9nwip",aitableId));  //AI表格映射ID

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }


    @Override
    public void updateSaleProjectRelatedAitableId(String formInstId, String aitableId) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        updateFormDataJson = JSONObject.toJSONString(UtilMap.map("textField_mno9p0lf",aitableId));  //AI表格映射ID

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void updateLtcSaleProjectRelatedCustomer(String formInstId, JSONArray customerAss) throws Exception {
        /*
            参数定义
         */
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String updateFormDataJson;  //更新内容

        /*
            初始化参数值
         */
        updateFormDataJson = JSONObject.toJSONString(UtilMap.map("associationFormField_mdf997wc",customerAss));  //客户

        /*
            更新数据
         */
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formInstId(formInstId);
        ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
    }

    @Override
    public void insertCustomerData(Map row) throws Exception {
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String customerLevel = "";
        if(row.get("customerLevel")!=null){
            customerLevel = row.get("customerLevel").toString();
        }
        String businessUserId = "";
        String[] businessUserIdArr = new String[]{};
        if(row.get("businessUserId")!=null){
            businessUserId = row.get("businessUserId").toString();
            businessUserIdArr = new String[]{row.get("businessUserId").toString()};
        }
        String businessUserName = "";
        if(row.get("businessUserName")!=null){
            businessUserName = row.get("businessUserName").toString();
        }
        String[] businessLeaderUserIdArr = new String[]{};
        if(row.get("businessLeaderUserId")!=null){
            businessLeaderUserIdArr = new String[]{row.get("businessLeaderUserId").toString()};
        }
        String[] businessDepartmentArr = new String[]{};
        if(row.get("businessDepartment")!=null){
            businessDepartmentArr = new String[]{row.get("businessDepartment").toString()};
        }
        Map customerRecord = UtilMap.map(
                "textField_lqanqe6j, "  //客户公司名（英文名）
                        +"textField_meks6pjp, " //客户验重
                        +"radioField_md6q7ox8, " //新老客户
                        +"selectField_mcsoft5i, " //客户当前分级
                        +"selectField_mhsvnqsv, " //客户潜在等级
                        +"employeeField_lqanqe6n, " //业务
                        +"textField_mnchujji, " //业务userId
                        +"textField_lxa0ko5h, " //业务name
                        +"employeeField_lqx3act6, " //业务组长
                        +"departmentSelectField_lympbaya, " //业务部门
                        +"radioField_md6q7oxa, " //公海/私海
                        +"textField_mno9nwip, " //AI表格映射ID
                        +"radioField_mnpdkss9", //测试使用
                row.get("customerName"),
                row.get("customerName1UpperCase"),
                row.get("newOrOld"),
                row.get("customerLevelActual"),
                customerLevel,
                businessUserIdArr,
                businessUserId,
                businessUserName,
                businessLeaderUserIdArr,
                businessDepartmentArr,
                row.get("seaType"),
                row.get("aiTableId"),
                row.get("testUseFlag")
        );
        String insertFormDataJson = JSONObject.toJSONString(customerRecord);
        System.out.println(insertFormDataJson);
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_CUSTOMER);
        ydParamBuilder = ydParamBuilder.formDataJson(insertFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.create);
        System.out.println("新增一条客户记录");
    }

    @Override
    public void insertSaleProjectData(Map row) throws Exception {
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建

        String businessUserId = "";
        String[] businessUserIdArr = new String[]{};
        if(row.get("businessUserId")!=null){
            businessUserId = row.get("businessUserId").toString();
            businessUserIdArr = new String[]{row.get("businessUserId").toString()};
        }

        List customerField = new ArrayList();
        Map customerFieldVal = new HashMap();
        customerFieldVal.put("appType","APP_GM7D1NW6XCD0ZJBPVH51");
        customerFieldVal.put("formUuid","FORM-9261FABA687B4D1D917617F53B4A5DB7UN16"); //客户
        customerFieldVal.put("formType","receipt");
        customerFieldVal.put("instanceId",row.get("customerId"));
        customerFieldVal.put("title",row.get("customerName"));
        customerFieldVal.put("subTitle",row.get("customerCode"));
        customerField.add(customerFieldVal);

        Map saleProjectRecord = UtilMap.map(
                "textField_mdf997vz, "  //项目名称
                +"textField_mdf997wb, " //项目英文名
                +"textField_mgrg3348, " //项目名称缩写
                +"associationFormField_mdf997wc, " //客户
                +"textField_mn48rz8y, " //客户公司名（英文名）
                +"textField_mdpb1gh1, " //客户编号
                +"employeeField_mdf997x2, " //业务员
                +"textField_mnctph7f, " //业务员userId
                +"selectField_mdf997ws, " //销售项目状态
                +"selectField_mdf997wp, " //整体项目阶段
                +"selectField_mfkv8ou2, " //成单情况
                +"numberField_mdf997x6, " //预计销售项目金额（美元）
                +"dateField_mdf997x7, " //预计成单日期
                +"dateField_mfm5x6cl, " //实际成单日期
                +"textField_mgykaadz, " //全局汇率单位
                +"textField_mhlrjdz2, " //原系统PI号
                +"textField_mno9p0lf, " //AI表格映射ID
                +"radioField_mo0xt19d, " //是否特殊客户
                +"radioField_mnppbub6", //测试使用
                row.get("projectName"),
                row.get("projectEnName"),
                row.get("pName"),
                customerField,
                row.get("customerName"),
                row.get("customerCode"),
                businessUserIdArr,
                businessUserId,
                "已完成",
                "S3：已签单",
                "已成单",
                row.get("projectAmount"),
                row.get("expectedCloseDate"),
                row.get("actualCloseDate"),
                "美元/人民币",
                row.get("piCode"),
                row.get("aiTableId"),
                "否",
                "否"
        );
        String insertFormDataJson = JSONObject.toJSONString(saleProjectRecord);
        System.out.println(insertFormDataJson);
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_SALE_PROJECT);
        ydParamBuilder = ydParamBuilder.formDataJson(insertFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.create);
        System.out.println("新增一条销售项目记录");
    }

    @Override
    public void addAlertDetail(Map row) throws Exception {
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建

        String[] businessUserIdArr = new String[]{};
        if(row.get("businessUserId")!=null){
            businessUserIdArr = new String[]{row.get("businessUserId").toString()};
        }

        List customerField = new ArrayList();
        Map customerFieldVal = new HashMap();
        customerFieldVal.put("appType","APP_GM7D1NW6XCD0ZJBPVH51");
        customerFieldVal.put("formUuid","FORM-9261FABA687B4D1D917617F53B4A5DB7UN16"); //客户
        customerFieldVal.put("formType","receipt");
        customerFieldVal.put("instanceId",row.get("formInstId"));
        customerFieldVal.put("title",row.get("customerName"));
        customerFieldVal.put("subTitle",row.get("customerCode"));
        customerField.add(customerFieldVal);

        Map alertLogRecord = UtilMap.map(
                "employeeField_mpf2mxcc, " //业务员
                        +"associationFormField_mpf2mxcb, " //客户
                        +"textareaField_mpghcehk, " //备注
                        +"dateField_mpf2mxcd", //提醒日期
                businessUserIdArr,
                customerField,
                row.get("remark"),
                row.get("today")
        );
        String insertFormDataJson = JSONObject.toJSONString(alertLogRecord);
        System.out.println(insertFormDataJson);
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_ALERT_DETAIL);
        ydParamBuilder = ydParamBuilder.formDataJson(insertFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.create);
        log.info("新增一条私海客户流出风险提示记录");
        Thread.sleep(1000);
    }

    @Override
    public void addAlertLog(Map row) throws Exception {
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建

        String[] businessUserIdArr = new String[]{};
        if(row.get("businessUserId")!=null){
            businessUserIdArr = new String[]{row.get("businessUserId").toString()};
        }

        Map alertLogRecord = UtilMap.map(
                "employeeField_mpgmbad0, " //业务员
                        +"numberField_mpgmbad2, " //超过3天未跟进客户数量
                        +"dateField_mpgmbad3", //发布日期
                businessUserIdArr,
                row.get("customerNum"),
                row.get("today")
        );
        String insertFormDataJson = JSONObject.toJSONString(alertLogRecord);
        System.out.println(insertFormDataJson);
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.formUuid(EastarParam.YD_FORMUUID_ALERT_LOG);
        ydParamBuilder = ydParamBuilder.formDataJson(insertFormDataJson);
        yidaParam = ydParamBuilder.build();
        ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.create);
        log.info("新增一条私海客户流出告警日志记录");
        Thread.sleep(3000);
    }

    @Override
    public List<Map> querySys2CustomerData() throws Exception {
        /*
            参数定义
         */
        List<Map> customerData = new ArrayList<>(); // 客户数据
        List<Map> customerDataDeduplicate = new ArrayList<>(); // 客户数据（去重）
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        String createToTimeGMT; //需要创建时间小于的时间
        String searchCondition; //检索条件
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String customerName;    //客户名称
        JSONArray businessUserJSONArray;  //对接业务员
        List<String> businessUserList;  //对接业务员（文本）
        String businessUserId;    //业务员userId
        String businessUserName;    //业务员姓名
        List<Map> kpRecords;  //KP明细
        String kp;  //KP
        boolean isCustomerNameEmpty;    //客户名称是否为空
        boolean isBusinessUserEmpty;    //业务员是否为空
        boolean isKpEmpty;  //KP是否为空
        boolean isBusinessUserMulti;    //业务员是否有多个
        boolean isKpMulti;  //KP是否有多个
        int customerEmptyCount = 0;  //客户名称为空的记录数
        Map<String,String> customerRecord;  //客户记录
        Map<String, Long> customerNameCountMap = new HashMap<>();   //客户名称与出现的次数映射
        String formInstId;  //表单实例ID

        /*
            EASTAR业务数字化
         */
        appType = "APP_BPEHQO5P5YSJ7GMIU9ST";
        systemToken = "6Q666BA1SP89K86O7K41AAQ1NS1228S93GJFL5P2";
        formUuid = "FORM-YZ9664D10Q89BB9CEYN3P8LQBRDQ34Y45GJFL6";

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId
        createToTimeGMT = "2026-04-09 09:15:44";
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.appType(appType);
        ydParamBuilder = ydParamBuilder.systemToken(systemToken);
        ydParamBuilder = ydParamBuilder.formUuid(formUuid);
        ydParamBuilder = ydParamBuilder.userId(userId);
        ydParamBuilder = ydParamBuilder.createToTimeGMT(createToTimeGMT);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        customerName = "";
        businessUserId = "";
        businessUserName = "";
        kp = "";
        formInstId = "";
        for(int i=0;i<allRecords.size();i++){
            /*
                重置是否为空标识
             */
            isCustomerNameEmpty = false;
            isBusinessUserEmpty = false;
            isKpEmpty = false;
            isBusinessUserMulti = false;
            isKpMulti = false;

            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(allRecords.get(i).get("formData")));

            /*
                获取客户名称数据
             */
            if(fields.get("textField_lfjg60xp") == null){
                isCustomerNameEmpty = true;
            }else{
                customerName = fields.getString("textField_lfjg60xp");
                customerName = customerName.replace("\n",""); //去除换行符
                customerName = customerName.trim(); //去除空格
                if(StringUtils.isEmpty(customerName)){
                    isCustomerNameEmpty = true;
                }
            }
            if(isCustomerNameEmpty){
                customerEmptyCount++;
//                throw new RuntimeException("客户公司名字段为空");
                continue;
            }else{
//                System.out.println("客户名称="+customerName);
            }

            /*
                获取业务员数据
             */
            if(fields.get("employeeField_lfjg60xx") == null){
                isBusinessUserEmpty = true;
            }else{
                businessUserJSONArray = fields.getJSONArray("employeeField_lfjg60xx");
                if(businessUserJSONArray.isEmpty()){
                    isBusinessUserEmpty = true;
                }else{
                    if(businessUserJSONArray.size()>1){ //一个客户有多个业务员负责对接
                        isBusinessUserMulti = true;
                        log.info("客户名称="+customerName+"，业务员数量="+businessUserJSONArray.size());
                    }
                    if(isBusinessUserMulti){
                        businessUserList = new ArrayList<>();
                        for (int j = 0; j < businessUserJSONArray.size(); j++) {
                            if (businessUserJSONArray.get(j) != null) {
                                businessUserList.add(String.valueOf(businessUserJSONArray.get(j)));
                            }
                        }
                        businessUserName = String.join(",", businessUserList);
//                        System.out.println("业务员="+businessUser);
                        continue;
                    }else{
                        businessUserName = String.valueOf(businessUserJSONArray.get(0));
                        businessUserJSONArray = fields.getJSONArray("employeeField_lfjg60xx_id");
                        businessUserId = String.valueOf(businessUserJSONArray.get(0));
                    }
                }
            }
//            System.out.println("业务员是否为空="+isBusinessUserEmpty);
            if(isBusinessUserEmpty){
//                throw new RuntimeException("对接业务员为空");
            }else{
//                System.out.println("业务员="+businessUser);
            }

            /*
                获取KP数据
             */
            /*
            if(allRecords.get(i).get("formInstanceId") != null){
                formInstId = String.valueOf(allRecords.get(i).get("formInstanceId"));
                ydParamBuilder = YDParam.builder();
                ydParamBuilder = ydParamBuilder.appType(appType);
                ydParamBuilder = ydParamBuilder.systemToken(systemToken);
                ydParamBuilder = ydParamBuilder.formUuid(formUuid);
                ydParamBuilder = ydParamBuilder.userId(userId);
                ydParamBuilder = ydParamBuilder.formInstanceId(formInstId);
                ydParamBuilder = ydParamBuilder.tableFieldId("tableField_m6yfc2c2");    //【新建客户】子表单【客户KP信息】
                yidaParam = ydParamBuilder.build();
                kpRecords = ydService.queryDetails(yidaParam);
                if(kpRecords == null || kpRecords.isEmpty()){
                    isKpEmpty = true;
                }else{
                    if(kpRecords.size() == 1){  //单个KP
                        if(kpRecords.get(0).get("textField_m6yfc2c3") == null
                                || "".equals(String.valueOf(kpRecords.get(0).get("textField_m6yfc2c3")))){ //KP姓名为空
                            isKpEmpty = true;
                        }else{
                            kp = String.valueOf(kpRecords.get(0).get("textField_m6yfc2c3"));
                        }
                    }else{  //多个KP
                        isKpEmpty = true;   //先假设所有记录KP为空
                        for (int j=0; j<kpRecords.size(); j++) {
                            if(kpRecords.get(j).get("textField_m6yfc2c3") == null
                                    || "".equals(String.valueOf(kpRecords.get(j).get("textField_m6yfc2c3")))){ //KP姓名为空
                                //忽略
                            }else{
                                isKpMulti = true;
                                isKpEmpty = false;  //只要有1条记录KP不为空，则更新标识
                                if(j == 0){
                                    kp = String.valueOf(kpRecords.get(j).get("textField_m6yfc2c3"));
                                }else{
                                    kp += "," + String.valueOf(kpRecords.get(j).get("textField_m6yfc2c3"));
                                }
                            }
                        }
                        if (isKpMulti) {
                            log.info("客户名称="+customerName+"，KP数量="+kp.split(",").length);
                        }
                    }
                }

            }
//            System.out.println("KP是否为空="+isKpEmpty);
            if(isKpEmpty){
//                throw new RuntimeException("KP姓名字段为空");
            }else{
//                System.out.println("KP="+kp);
            }
             */

            /*
                汇总客户数据
             */
            customerRecord = new HashMap<>();
            customerRecord.put("customerName",customerName);
            customerRecord.put("businessUserName",businessUserName);
            customerRecord.put("businessUserId",businessUserId);
//            customerRecord.put("kp",kp);
//            System.out.println(JSONObject.toJSONString(customerRecord));
            customerData.add(customerRecord);
        }
        log.info("客户名称为空的记录数="+customerEmptyCount);

        /*
            排除有重复的客户
         */
        for (Map<String, String> record : customerData) {
            customerName = record.get("customerName");
            customerNameCountMap.merge(customerName, 1L, Long::sum);
        }
        for (Map.Entry<String, Long> entry : customerNameCountMap.entrySet()) {
            if (entry.getValue() > 1) {
                System.out.println("客户名称="+entry.getKey()+"，重复次数="+ entry.getValue());
            }
        }
        for (Map<String, String> record : customerData) {
            customerName = record.get("customerName");
            if(customerNameCountMap.get(customerName)==1){
                customerDataDeduplicate.add(record);
            }
        }

        return customerDataDeduplicate;
    }

    @Override
    public void updateSys1Sys2CustomerPart2Data(List<Map> sys2CustomerData) throws Exception {
        /*
            参数定义
         */
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        YDSearch ydSearch; //检索条件（单个）
        String searchCondition; //检索条件
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        String customerName;    //客户名称
        String kp;  //KP
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //记录数据
        JSONObject fields;  //字段数据
        String formInstId;  //表单实例ID
        String updateFormDataJson;  //更新内容

        /*
            客户数据清洗
         */
        appType = "APP_IL6UN1IETFL3GATLFU0Z";
        systemToken = "2MA66S71ZRH4FN2FJKW985LDOEBT30F3D7INMGMT";
        formUuid = "FORM-30D3F6A5F4E34B459810BBB53619BDB8LX5I"; //客户名册part2

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId

        /*
            遍历所有客户记录，通过客户名称去（客户数据清洗）找到对应记录，并更新KP姓名
         */
        for (Map<String, String> customerRecord : sys2CustomerData) {
            /*
                通过客户名称去（客户数据清洗）找到对应记录
             */
            customerName = customerRecord.get("customerName");
            kp = customerRecord.get("kp");
            System.out.println("customerName="+customerName+",kp="+kp);
            ydParamBuilder = YDParam.builder();
            ydParamBuilder = ydParamBuilder.appType(appType);
            ydParamBuilder = ydParamBuilder.systemToken(systemToken);
            ydParamBuilder = ydParamBuilder.formUuid(formUuid);
            ydParamBuilder = ydParamBuilder.userId(userId);
            ydSearch = new YDSearch(
                    "textField_3utukqf",
                    customerName,
                    "客户公司名",
                    YDSearch.Type.TEXT_FIELD,
                    YDSearch.Operator.EQ
            );
            searchCondition = JSONObject.toJSONString(Arrays.asList(ydSearch));
            ydParamBuilder.searchCondition(searchCondition);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            records = (List<Map>) yidaResult.getData();
//            fields = JSONObject.parseObject(JSONObject.toJSONString(records.get(0).get("formData")));
            if(!records.isEmpty() && records.get(0) != null){
                formInstId = String.valueOf(records.get(0).get("formInstanceId"));
//                System.out.println("formInstId="+formInstId);
                /*
                    更新KP姓名
                 */
                updateFormDataJson = JSONObject.toJSONString(UtilMap.map("textField_h1e7kac",kp));  //KP姓名
                ydParamBuilder = YDParam.builder();
                ydParamBuilder = ydParamBuilder.appType(appType);
                ydParamBuilder = ydParamBuilder.systemToken(systemToken);
                ydParamBuilder = ydParamBuilder.formUuid(formUuid);
                ydParamBuilder = ydParamBuilder.userId(userId);
                ydParamBuilder = ydParamBuilder.formInstId(formInstId);
                ydParamBuilder = ydParamBuilder.updateFormDataJson(updateFormDataJson);
                yidaParam = ydParamBuilder.build();
                ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.update);
            }

        }
        System.out.println("更新所有KP完成");
    }

    @Override
    public void insertSys1Sys2CustomerAllData(List<Map> sys1Sys2CustomerData) throws Exception {
        /*
            参数定义
         */
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        Map<String,Object> customerRecord;  //待插入记录
        int customerRecordCount;    //操作客户记录数
        String insertFormDataJson;  //新增内容

        /*
            客户数据清洗
         */
        appType = "APP_IL6UN1IETFL3GATLFU0Z";
        systemToken = "2MA66S71ZRH4FN2FJKW985LDOEBT30F3D7INMGMT";
        formUuid = "FORM-300D7134EEB446AE82A6FDF330FAD006Q4HO"; //客户名册all

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId

        /*
            遍历所有客户记录，通过客户名称去（客户数据清洗）找到对应记录，并更新KP姓名
         */
        customerRecordCount = 0;
        for (Map<String, String> sys1Sys2CustomerRecord : sys1Sys2CustomerData) {
            customerRecord = UtilMap.map(
                    "textField_mnwhxldz, "  //客户名称
                    +"textField_mnwl12wu, " //业务（项目总表）
                    +"textField_mnwl12wv, " //业务（EASTAR业务数字化）
                    +"textField_mnwl12ww, " //sys1unionid
                    +"textField_mnwl12wx, " //sys1userid
                    +"textField_mnwl12wy, " //sys2userid
                    +"selectField_mnx00f7g, " //数据来源标记
                    +"selectField_mnwt8opl",   //是否有差异
                    sys1Sys2CustomerRecord.get("customerName"),
                    sys1Sys2CustomerRecord.get("sys1BusinessUserName"),
                    sys1Sys2CustomerRecord.get("sys2BusinessUserName"),
                    sys1Sys2CustomerRecord.get("sys1unionid"),
                    sys1Sys2CustomerRecord.get("sys1userid"),
                    sys1Sys2CustomerRecord.get("sys2userid"),
                    sys1Sys2CustomerRecord.get("source"),
                    sys1Sys2CustomerRecord.get("isAnyDifference")
            );
            insertFormDataJson = JSONObject.toJSONString(customerRecord);  //KP姓名
            ydParamBuilder = YDParam.builder();
            ydParamBuilder = ydParamBuilder.appType(appType);
            ydParamBuilder = ydParamBuilder.systemToken(systemToken);
            ydParamBuilder = ydParamBuilder.formUuid(formUuid);
            ydParamBuilder = ydParamBuilder.userId(userId);
            ydParamBuilder = ydParamBuilder.formDataJson(insertFormDataJson);
            yidaParam = ydParamBuilder.build();
            ydClient.operateData(yidaParam,YDConf.FORM_OPERATION.create);
            customerRecordCount++;
            if(customerRecordCount % 100 == 0){
                System.out.println("已处理"+customerRecordCount+"条客户数据");
            }
        }
        if(customerRecordCount % 100 != 0){
            System.out.println("已处理"+customerRecordCount+"条客户数据");
        }
        System.out.println("新增客户名册完成");
    }

    @Override
    public List<Map> querySys1Sys2CustomerAllData() throws Exception {
        /*
            参数定义
         */
        List<Map> sys1Sys2CustomerData = new ArrayList<>();
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String customerName;    //客户名称
        Map customerRecord;  //客户记录

        /*
            客户数据清洗
         */
        appType = "APP_IL6UN1IETFL3GATLFU0Z";
        systemToken = "2MA66S71ZRH4FN2FJKW985LDOEBT30F3D7INMGMT";
        formUuid = "FORM-300D7134EEB446AE82A6FDF330FAD006Q4HO"; //客户名册all

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.appType(appType);
        ydParamBuilder = ydParamBuilder.systemToken(systemToken);
        ydParamBuilder = ydParamBuilder.formUuid(formUuid);
        ydParamBuilder = ydParamBuilder.userId(userId);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map sys1Sys2CustomerRecord : allRecords){
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(sys1Sys2CustomerRecord.get("formData")));
            //生成客户数据
            customerRecord = UtilMap.map(
                    "customerName, source",
                    fields.getString("textField_mnwhxldz"), //客户名称
                    fields.getString("selectField_mnx00f7g")  //数据来源标记
            );
            sys1Sys2CustomerData.add(customerRecord);
        }

        return sys1Sys2CustomerData;
    }

    @Override
    public List<Map> querySys1Sys2PrivateCustomerData() throws Exception {
        /*
            参数定义
         */
        List<Map> sys1Sys2CustomerData = new ArrayList<>();
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String customerName;    //客户名称
        Map customerRecord;  //客户记录

        /*
            客户数据清洗
         */
        appType = "APP_IL6UN1IETFL3GATLFU0Z";
        systemToken = "2MA66S71ZRH4FN2FJKW985LDOEBT30F3D7INMGMT";
        formUuid = "FORM-EB1BD51283D44F3CA32ECCF05549D659EU2V"; //私海客户

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.appType(appType);
        ydParamBuilder = ydParamBuilder.systemToken(systemToken);
        ydParamBuilder = ydParamBuilder.formUuid(formUuid);
        ydParamBuilder = ydParamBuilder.userId(userId);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map sys1Sys2CustomerRecord : allRecords){
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(sys1Sys2CustomerRecord.get("formData")));
            //生成客户数据
            customerRecord = UtilMap.map(
                    "customerName, businessUserId",
                    fields.getString("textField_zj7gvgw"), //客户名称
                    fields.getString("textField_uj4ys0h")  //确认后业务userid
            );
            sys1Sys2CustomerData.add(customerRecord);
        }

        return sys1Sys2CustomerData;
    }

    @Override
    public List<Map> querySys1Sys2PublicCustomerData() throws Exception {
        /*
            参数定义
         */
        List<Map> sys1Sys2CustomerData = new ArrayList<>();
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String customerName;    //客户名称
        Map customerRecord;  //客户记录

        /*
            客户数据清洗
         */
        appType = "APP_IL6UN1IETFL3GATLFU0Z";
        systemToken = "2MA66S71ZRH4FN2FJKW985LDOEBT30F3D7INMGMT";
        formUuid = "FORM-9145B2CE607E4A7384932B9E10DAF968T2HQ"; //公海客户

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.appType(appType);
        ydParamBuilder = ydParamBuilder.systemToken(systemToken);
        ydParamBuilder = ydParamBuilder.formUuid(formUuid);
        ydParamBuilder = ydParamBuilder.userId(userId);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map sys1Sys2CustomerRecord : allRecords){
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(sys1Sys2CustomerRecord.get("formData")));
            //生成客户数据
            customerRecord = UtilMap.map(
                    "customerName, flag",
                    fields.getString("textField_oaveera"), //客户名称
                    fields.getString("textField_xo5uzls")  //数据同步标识
            );
            sys1Sys2CustomerData.add(customerRecord);
        }

        return sys1Sys2CustomerData;
    }

    @Override
    public List<Map> querySys1Sys2UncooperativeCustomerData() throws Exception {
        /*
            参数定义
         */
        List<Map> sys1Sys2CustomerData = new ArrayList<>();
        String appType; //宜搭应用编码
        String formUuid;    //表单编码
        String systemToken; //宜搭应用密钥
        String userId;  //用户userId
        YDParam yidaParam;  //HTTP请求体
        YDParam.YDParamBuilder ydParamBuilder; //宜搭参数构建
        DDR_New yidaResult; //请求返回内容
        List<Map> records;  //每页记录数据
        List<Map> allRecords = new ArrayList<>();  //所有记录数据
        boolean hasMore; //是否还有下一页
        int pageNo; //当前页码
        int pageSize;   //每页获取的数据量（上限100）
        JSONObject fields;  //字段数据
        String customerName;    //客户名称
        Map customerRecord;  //客户记录

        /*
            客户数据清洗
         */
        appType = "APP_IL6UN1IETFL3GATLFU0Z";
        systemToken = "2MA66S71ZRH4FN2FJKW985LDOEBT30F3D7INMGMT";
        formUuid = "FORM-68B079CC52544CDFBA470D82FB3A6F1F4JJY"; //不合作客户

        /*
            初始化参数值
         */
        userId = "02322511193621446331";    //操作人（Jason）的userId
        hasMore = true; //第一页默认有数据
        pageNo = 1;
        pageSize = 100;
        ydParamBuilder = YDParam.builder();
        ydParamBuilder = ydParamBuilder.appType(appType);
        ydParamBuilder = ydParamBuilder.systemToken(systemToken);
        ydParamBuilder = ydParamBuilder.formUuid(formUuid);
        ydParamBuilder = ydParamBuilder.userId(userId);

        /*
            翻页获取数据
         */
        while(hasMore){
            ydParamBuilder = ydParamBuilder.pageNumber(pageNo);
            ydParamBuilder = ydParamBuilder.pageSize(pageSize);
            yidaParam = ydParamBuilder.build();
            yidaResult = ydClient.queryData(yidaParam,YDConf.FORM_QUERY.retrieve_list);
            log.info("当前第"+pageNo+"页");
            records = (List<Map>) yidaResult.getData();
            log.info("记录数="+records.size());
            for (Map record : records){
                allRecords.add(record);
            }
            if((pageNo*pageSize) < yidaResult.getTotalCount()){
                pageNo++;
            }else{
                hasMore = false;
            }
            log.info("是否有更多数据："+hasMore);
            Thread.sleep(3000);
        }

        /*
            请求记录数据处理
         */
        log.info("所有记录数量="+allRecords.size());
        for (Map sys1Sys2CustomerRecord : allRecords){
            //解析字段数据
            fields = JSONObject.parseObject(JSONObject.toJSONString(sys1Sys2CustomerRecord.get("formData")));
            //生成客户数据
            customerRecord = UtilMap.map(
                    "customerName, flag",
                    fields.getString("textField_2hfi682"), //客户名称
                    fields.getString("textField_3qntf3x")  //数据同步标识
            );
            sys1Sys2CustomerData.add(customerRecord);
        }

        return sys1Sys2CustomerData;
    }


}