jyjt/bamp/basedata/webapi/SupplierSaveWebApiPlugin.java

package bamp.basedata.webapi;

import kd.bos.dataentity.OperateOption;
import kd.bos.dataentity.entity.DynamicObject;
import kd.bos.dataentity.entity.DynamicObjectCollection;
import kd.bos.entity.operate.result.OperateErrorInfo;
import kd.bos.entity.operate.result.OperationResult;
import kd.bos.entity.validate.ValidateResult;
import kd.bos.entity.validate.ValidateResultCollection;
import kd.bos.logging.Log;
import kd.bos.logging.LogFactory;
import kd.bos.openapi.common.custom.annotation.ApiController;
import kd.bos.openapi.common.custom.annotation.ApiMapping;
import kd.bos.openapi.common.custom.annotation.ApiParam;
import kd.bos.openapi.common.custom.annotation.ApiPostMapping;
import kd.bos.openapi.common.result.CustomApiResult;
import kd.bos.orm.query.QCP;
import kd.bos.orm.query.QFilter;
import kd.bos.servicehelper.BusinessDataServiceHelper;
import kd.bos.servicehelper.operation.OperationServiceHelper;
import kd.bos.servicehelper.operation.SaveServiceHelper;

import java.io.Serializable;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
 * 供应商修改插件
 * wangj 2025-02-05
 * 主要功能：修改主数据供应商
 */
@SuppressWarnings("all")
@ApiController(value = "open", desc = "供应商修改接口插件")
@ApiMapping(value = "/bd_supplier")
public class SupplierSaveWebApiPlugin implements Serializable {
    int successCount = 0;
    int failCount = 0;
    private static final Log log = LogFactory.getLog(SupplierAddnewWebApiPlugin.class);
    @ApiPostMapping(value = "supplier_save", desc = "同步接口")
    public CustomApiResult<Map<String, Object>> supplier_save(@ApiParam(value = "提交参数") List<Map<String, Object>> data ) {
        CustomApiResult customApiResult = new CustomApiResult();
        customApiResult.setStatus(true);
        customApiResult.setErrorCode("0");
        try {
            Map resultDatasMap = new HashMap();
            List<Map> resultDatas = new ArrayList<Map>();
            for(Map param : data){
                Map resultData = new HashMap();
                try {
                    doUpdateSupplier(param,resultData);
                }catch (Exception e) {
                    resultData.put("id","");
                    resultData.put("errors",e.getMessage());
                    resultData.put("billStatus",false);
                    failCount ++;
                }
                resultDatas.add(resultData);
            }
            resultDatasMap.put("failCount",failCount);
            resultDatasMap.put("successCount",successCount);
            if(failCount>0){
                customApiResult.setStatus(false);
                customApiResult.setErrorCode("603");
            }
            resultDatasMap.put("result",resultDatas);
            customApiResult.setData(resultDatasMap);
        } catch (Exception e) {
            customApiResult.setStatus(false);
            customApiResult.setMessage(e.getMessage());
            customApiResult.setErrorCode("400");
        }

        return customApiResult;
    }

    private void doUpdateSupplier(Map param, Map resultData) throws ParseException {
        String errorMsg = "";
        //创建新用户
        DynamicObject supplierObj = null;
        if(param.get("number")!=null){
            QFilter qFilter_number = new QFilter("number", QCP.equals,param.get("number"));
            DynamicObject[] customer = BusinessDataServiceHelper.load("bd_supplier","id",new QFilter[]{qFilter_number});
            if(customer.length>0){//防止新增失败情况留存的历史数据
                supplierObj = BusinessDataServiceHelper.loadSingle(customer[0].getPkValue(),"bd_supplier");
                if(param.get("enable")!=null && !"".equals(param.get("enable")) && "0".equals(param.get("enable"))){//使用状态变为禁用
                    //禁用人
                    setDynamicField(true,"modifier_number","disabler","bos_user",param,resultData,supplierObj);
                    //禁用时间
                    setDateField(true,"modifytime","disabledate",param,resultData,supplierObj);
                    //使用状态
                    supplierObj.set("enable","0");
                }
                //更新供应商子码基础资料
                if(param.get("pznm_zmentry")!=null){
                    List<Map> mapEntrys = (List<Map>) param.get("pznm_zmentry");
                    doSetEntry(mapEntrys,resultData,supplierObj);
                }
            }else{
                supplierObj = BusinessDataServiceHelper.newDynamicObject("bd_supplier");
                //数据状态
                supplierObj.set("status","A");
            }
            resultData.put("number",param.get("number"));
        }

        //供应商编码
        setTextField(true,"number","number",param,resultData,supplierObj);
        //供应商名称
        setTextField(true,"name","name",param,resultData,supplierObj);
        //修改人
        setDynamicField(true,"modifier_number","pznm_modifier_xh","bos_user",param,resultData,supplierObj);
        //修改时间
        setDateField(true,"modifytime","modifytime",param,resultData,supplierObj);
        //审核人
        setDynamicField(true,"approverid_number","pznm_auditor_xh","bos_user",param,resultData,supplierObj);
        //审核日期
        setDateField(true,"approvedate","approvedate",param,resultData,supplierObj);
        //创建组织
        setDynamicField(true,"createorg_number","createorg","bos_org",param,resultData,supplierObj);
        //控制策略
        setTextField(true,"ctrlstrategy","ctrlstrategy",param,resultData,supplierObj);
        //详细地址
        setTextField(false,"bizpartner_address","bizpartner_address",param,resultData,supplierObj);
        //统一社会信用代码
        setTextField(false,"societycreditcode","societycreditcode",param,resultData,supplierObj);
        //是否关联单位
        setTextField(false,"pznm_isrelateunit","pznm_isrelateunit",param,resultData,supplierObj);
        //内部业务单元
        setDynamicField(false,"internal_company_number","internal_company","bos_org",param,resultData,supplierObj);
        //是否内部单位
        setTextField(false,"chkisinternalcompany","chkisinternalcompany",param,resultData,supplierObj);
        //供应商分类
        if(param.get("entry_groupstandard")!=null){
            List<Map> mapEntrys = (List<Map>) param.get("entry_groupstandard");
            doSetGroupEntry(mapEntrys,resultData,supplierObj);
        }
        //银行信息
        if(param.get("entry_bank")!=null){
            List<Map> mapEntrys = (List<Map>) param.get("entry_bank");
            doSetBankEntry(mapEntrys,resultData,supplierObj);
        }
        //委托人分录
        if(param.get("pznm_wtrentry")!=null){
            List<Map> mapEntrys = (List<Map>) param.get("pznm_wtrentry");
            doSetWtrEntry(mapEntrys,resultData,supplierObj);
        }
        //控制状态分录
        if(param.get("pznm_kzztentry")!=null){
            List<Map> mapEntrys = (List<Map>) param.get("pznm_kzztentry");
            doSetKzztentry(mapEntrys,resultData,supplierObj);
        }
        if(resultData.get("errors")!=null && !"".equals(resultData.get("errors"))){
            List errors = new ArrayList();
            errors.add(resultData.get("errors"));
            resultData.put("id","");
            resultData.put("errors",errors);
            resultData.put("billStatus",false);
            failCount ++;
        }else{
            //保存供应商对象
            String status = supplierObj.getString("status");
            if("A".equals(status)){//暂存，走正常逻辑
                doAddNew(resultData,supplierObj,param);
            }else if("B".equals(status)){//已提交，走update和审核
                doUpdateAndAudit(resultData,supplierObj);
            }else if("C".equals(status)){//已审核，走修改逻辑
                doUpdate(resultData,supplierObj);
            }
        }
    }

    private void doUpdate(Map resultData, DynamicObject supplierObj) {
        SaveServiceHelper.update(supplierObj);
        resultData.put("errors",new ArrayList());
        resultData.put("id",supplierObj.getPkValue());
        resultData.put("billStatus", true);
        successCount++;
    }

    private void doUpdateAndAudit(Map resultData, DynamicObject supplierObj) {
        SaveServiceHelper.update(supplierObj);
        OperationResult result_audit = OperationServiceHelper.executeOperate("audit", "bd_supplier",
                new DynamicObject[]{supplierObj}, OperateOption.create());
        //执行供应商对应组织分配
        if(result_audit.isSuccess()){//保存供应商成功
            resultData.put("errors",new ArrayList());
            resultData.put("id",result_audit.getSuccessPkIds().get(0));
            resultData.put("billStatus", true);
            successCount++;
        }else{//提交供应商失败
            List errors = new ArrayList();
            ValidateResultCollection validateResults = result_audit.getValidateResult();
            List<ValidateResult> validateResultList = validateResults.getValidateErrors();
            for(ValidateResult validateResult : validateResultList){
                List<OperateErrorInfo> allErrorInfos = validateResult.getAllErrorInfo();
                for(OperateErrorInfo allErrorInfo : allErrorInfos){
                    errors.add(allErrorInfo.getMessage());
                }
            }
            resultData.put("errors",errors);
            resultData.put("id","");
            resultData.put("billStatus", false);
            failCount ++;
        }
    }

    private void doAddNew(Map resultData, DynamicObject supplierObj, Map param) {
        OperationResult result_submit = OperationServiceHelper.executeOperate("submit", "bd_supplier",
                new DynamicObject[]{supplierObj}, OperateOption.create());
        if(result_submit.isSuccess()){
            OperationResult result_audit = OperationServiceHelper.executeOperate("audit", "bd_supplier",
                    new DynamicObject[]{supplierObj}, OperateOption.create());
            //执行供应商对应组织分配
            if(result_audit.isSuccess()){//保存供应商成功
                //更新供应商子码基础资料
                if(param.get("pznm_zmentry")!=null){
                    List<Map> mapEntrys = (List<Map>) param.get("pznm_zmentry");
                    doSetEntry(mapEntrys,resultData,supplierObj);
                }

                if(resultData.get("errors")!=null && !"".equals(resultData.get("errors"))){
                    List errors = new ArrayList();
                    errors.add(resultData.get("errors"));
                    resultData.put("errors",errors);
                    resultData.put("id","");
                    resultData.put("billStatus", false);
                    failCount ++;
                }else{
                    resultData.put("errors",new ArrayList());
                    resultData.put("id",result_audit.getSuccessPkIds().get(0));
                    resultData.put("billStatus", true);
                    successCount++;
                }
            }else{//提交供应商失败
                List errors = new ArrayList();
                ValidateResultCollection validateResults = result_audit.getValidateResult();
                List<ValidateResult> validateResultList = validateResults.getValidateErrors();
                for(ValidateResult validateResult : validateResultList){
                    List<OperateErrorInfo> allErrorInfos = validateResult.getAllErrorInfo();
                    for(OperateErrorInfo allErrorInfo : allErrorInfos){
                        errors.add(allErrorInfo.getMessage());
                    }
                }
                resultData.put("errors",errors);
                resultData.put("id","");
                resultData.put("billStatus", false);
                failCount ++;
            }
        }else{
            List errors = new ArrayList();
            ValidateResultCollection validateResults = result_submit.getValidateResult();
            List<ValidateResult> validateResultList = validateResults.getValidateErrors();
            for(ValidateResult validateResult : validateResultList){
                List<OperateErrorInfo> allErrorInfos = validateResult.getAllErrorInfo();
                for(OperateErrorInfo allErrorInfo : allErrorInfos){
                    errors.add(allErrorInfo.getMessage());
                }
            }
            resultData.put("errors",errors);
            resultData.put("id","");
            resultData.put("billStatus", false);
            failCount ++;
        }
    }

    private void doSetGroupEntry(List<Map> mapEntrys, Map resultData, DynamicObject supplierObj) {
        DynamicObjectCollection entrys = supplierObj.getDynamicObjectCollection("entry_groupstandard");
        entrys.clear();
        for(Map mapEntry : mapEntrys) {
            DynamicObject newEntry = new DynamicObject(entrys.getDynamicObjectType());
            //分类标准.编码
            setDynamicField(true, "standardid_number", "standardid", "bd_suppliergroupstandard",
                    mapEntry, resultData, newEntry);
            //分类.编码
            setDynamicField(false,"groupid_number","groupid","bd_suppliergroup",
                    mapEntry,resultData,newEntry);
            entrys.add(newEntry);
        }
    }

    private void doSetBankEntry(List<Map> mapEntrys, Map resultData, DynamicObject supplierObj) {
        DynamicObjectCollection entrys = supplierObj.getDynamicObjectCollection("entry_bank");
        entrys.clear();
        for(Map mapEntry : mapEntrys) {
            DynamicObject newEntry = new DynamicObject(entrys.getDynamicObjectType());
            //所属组织
            setDynamicField(true, "pznm_bket_org_number", "pznm_bket_org", "bos_org",
                    mapEntry, resultData, newEntry);
            //银行账号
            setTextField(true, "bankaccount", "bankaccount", mapEntry, resultData, newEntry);
            //账户名称
            setTextField(true, "accountname", "accountname", mapEntry, resultData, newEntry);
            //开户银行
            setDynamicField(true,"bank_number","bank","bd_bebank",
                    mapEntry,resultData,newEntry);
            //币别
            setDynamicField(true,"currency_number","currency","bd_currency",
                    mapEntry,resultData,newEntry);
            //默认
            setTextField(true, "isdefault_bank", "isdefault_bank", mapEntry, resultData, newEntry);
            //账户性质
            setTextField(false, "pznm_bket_account", "pznm_bket_account", mapEntry, resultData, newEntry);
            entrys.add(newEntry);
        }
    }

    private void doSetEntry(List<Map> mapEntrys, Map resultData, DynamicObject supplierObj) {
        //拼接组织+字码编码的过滤条件
        List<String> zmnumbers = new ArrayList<String>();
        List<String> orgnumbers = new ArrayList<String>();
        for(Map mapEntry : mapEntrys){
            zmnumbers.add(mapEntry.get("pznm_zmet_number").toString());
            orgnumbers.add(mapEntry.get("pznm_zmet_org_number").toString());
        }

        //查询过滤条件，缓存存在的字码Map记录
        Map isHaveOrgs_zmnumber = new HashMap();
        QFilter qFilter_customer = new QFilter("pznm_supplier",QCP.equals,supplierObj.getPkValue());
        QFilter qFilter_org = new QFilter("pznm_zmet_org.number",QCP.in,orgnumbers);
        QFilter qFilter_ztnumber = new QFilter("number",QCP.in,zmnumbers);
        DynamicObject[] isHaveObjs = BusinessDataServiceHelper.load("pznm_supplierzm",
                "id,pznm_zmet_org,pznm_zmet_org.number,pznm_zmet_number,pznm_zmet_name,pznm_zmet_oldnumber,pznm_zmet_wtr,pznm_zmet_wtrphone," +
                        "pznm_zmet_lxr,pznm_zmet_lxrphone,pznm_zmet_cgper,pznm_zmet_setttype," +
                        "pznm_zmet_zqnotes,pznm_zmet_settday,pznm_zmet_zqrtype,pznm_zmet_zqptype,pznm_zmet_paytype,pznm_zmet_invoicetype",
                new QFilter[]{qFilter_customer,qFilter_org,qFilter_ztnumber});
        for(DynamicObject obj : isHaveObjs){
            DynamicObject org =  (DynamicObject) obj.getDynamicObject("pznm_zmet_org");
            String org_zmnumber = org.getString("number")+"_"+obj.getString("number");
            isHaveOrgs_zmnumber.put(org_zmnumber,obj);
        }

        //区分并拼接需更新和新增的记录
        DynamicObjectCollection add_entrys = new DynamicObjectCollection();
        DynamicObjectCollection update_entrys = new DynamicObjectCollection();
        for(Map mapEntry : mapEntrys){
            String org_zmnumber = mapEntry.get("pznm_zmet_org_number").toString()+"_"+mapEntry.get("pznm_zmet_number").toString();
            if(isHaveOrgs_zmnumber.get(org_zmnumber)!=null && !"".equals(isHaveOrgs_zmnumber.get(org_zmnumber))){
                //已存在，缓存修改对象
                DynamicObject update_entry = (DynamicObject) isHaveOrgs_zmnumber.get(org_zmnumber);

                setDynamicField(true,"pznm_zmet_org_number","pznm_zmet_org","bos_org",
                        mapEntry,resultData,update_entry);
                //供应商子码.子码编码
                setTextField(true,"pznm_zmet_number","number",mapEntry,resultData,update_entry);
                //供应商子码.子码名称
                setTextField(true,"pznm_zmet_name","name",mapEntry,resultData,update_entry);
                //供应商子码.老系统编号
                setTextField(false,"pznm_zmet_oldnumber","pznm_zmet_oldnumber",mapEntry,resultData,update_entry);
                //委托人.编码
                setDynamicField(false,"pznm_zmet_wtr_number","pznm_zmet_wtr","pznm_outcontacts",
                        mapEntry,resultData,update_entry);
                //委托人信息.委托人电话
                setTextField(false,"pznm_zmet_wtrphone","pznm_zmet_wtrphone",mapEntry,resultData,update_entry);
                //联系人.编码
                setDynamicField(false,"pznm_zmet_lxr_number","pznm_zmet_lxr","pznm_outcontacts",
                        mapEntry,resultData,update_entry);
                //供应商子码.联系人电话
                setTextField(false,"pznm_zmet_lxrphone","pznm_zmet_lxrphone",mapEntry,resultData,update_entry);
                //供应商子码.采购负责人.工号
                setDynamicField(false,"pznm_zmet_cgper_number","pznm_zmet_cgper","bos_user",
                        mapEntry,resultData,update_entry);
                //结算类型.编码
                setDynamicField(false,"pznm_zmet_setttype_number","pznm_zmet_setttype","pznm_settlementtype",
                        mapEntry,resultData,update_entry);
                //供应商子码.账期摘要
                setTextField(false,"pznm_zmet_zqnotes","pznm_zmet_zqnotes",mapEntry,resultData,update_entry);
                //供应商子码.实销实结结算日
                setTextField(false,"pznm_zmet_settday","pznm_zmet_settday",mapEntry,resultData,update_entry);
                //账期类型(收款).编码
                setDynamicField(false,"pznm_zmet_zqrtype_number","pznm_zmet_zqrtype","bd_reccondition",
                        mapEntry,resultData,update_entry);
                //账期类型(付款).编码
                setDynamicField(false,"pznm_zmet_zqptype_number","pznm_zmet_zqptype","bd_paycondition",
                        mapEntry,resultData,update_entry);
                //支付方式.编码
                setDynamicField(false,"pznm_zmet_paytype_number","pznm_zmet_paytype","bd_settlementtype",
                        mapEntry,resultData,update_entry);
                //发票类型.编码
                setDynamicField(false,"pznm_zmet_invoicetype_number","pznm_zmet_invoicetype","bd_invoicetype",
                        mapEntry,resultData,update_entry);
                update_entrys.add(update_entry);
            }else{
                //不存在，缓存新增对象
                DynamicObject add_entry = BusinessDataServiceHelper.newDynamicObject("pznm_supplierzm");

                setDynamicField(true,"pznm_zmet_org_number","pznm_zmet_org","bos_org",
                        mapEntry,resultData,add_entry);
                //供应商子码.子码编码
                setTextField(true,"pznm_zmet_number","number",mapEntry,resultData,add_entry);
                //供应商子码.子码名称
                setTextField(true,"pznm_zmet_name","name",mapEntry,resultData,add_entry);
                //供应商子码.老系统编号
                setTextField(false,"pznm_zmet_oldnumber","pznm_zmet_oldnumber",mapEntry,resultData,add_entry);
                //委托人.编码
                setDynamicField(false,"pznm_zmet_wtr_number","pznm_zmet_wtr","pznm_outcontacts",
                        mapEntry,resultData,add_entry);
                //委托人信息.委托人电话
                setTextField(false,"pznm_zmet_wtrphone","pznm_zmet_wtrphone",mapEntry,resultData,add_entry);
                //联系人.编码
                setDynamicField(false,"pznm_zmet_lxr_number","pznm_zmet_lxr","pznm_outcontacts",
                        mapEntry,resultData,add_entry);
                //供应商子码.联系人电话
                setTextField(false,"pznm_zmet_lxrphone","pznm_zmet_lxrphone",mapEntry,resultData,add_entry);
                //供应商子码.采购负责人.工号
                setDynamicField(false,"pznm_zmet_cgper_number","pznm_zmet_cgper","bos_user",
                        mapEntry,resultData,add_entry);
                //结算类型.编码
                setDynamicField(false,"pznm_zmet_setttype_number","pznm_zmet_setttype","pznm_settlementtype",
                        mapEntry,resultData,add_entry);
                //客户子码.账期摘要
                setTextField(false,"pznm_zmet_zqnotes","pznm_zmet_zqnotes",mapEntry,resultData,add_entry);
                //客户子码.实销实结结算日
                setTextField(false,"pznm_zmet_settday","pznm_zmet_settday",mapEntry,resultData,add_entry);
                //账期类型(收款).编码
                setDynamicField(false,"pznm_zmet_zqrtype_number","pznm_zmet_zqrtype","bd_reccondition",
                        mapEntry,resultData,add_entry);
                //账期类型(付款).编码
                setDynamicField(false,"pznm_zmet_zqptype_number","pznm_zmet_zqptype","bd_paycondition",
                        mapEntry,resultData,add_entry);
                //支付方式.编码
                setDynamicField(false,"pznm_zmet_paytype_number","pznm_zmet_paytype","bd_settlementtype",
                        mapEntry,resultData,add_entry);
                //发票类型.编码
                setDynamicField(false,"pznm_zmet_invoicetype_number","pznm_zmet_invoicetype","bd_invoicetype",
                        mapEntry,resultData,add_entry);
                //供应商
                add_entry.set("pznm_supplier",supplierObj);
                //数据状态
                add_entry.set("status","A");
                //使用状态
                add_entry.set("enable","1");
                add_entrys.add(add_entry);
            }
        }

        DynamicObject[] real_update_entrys = new DynamicObject[update_entrys.size()];
        for(int i=0;i< update_entrys.size();i++){
            real_update_entrys[i] = update_entrys.get(i);
        }

        DynamicObject[] real_add_entrys = new DynamicObject[add_entrys.size()];
        for(int i=0;i< add_entrys.size();i++){
            real_add_entrys[i] = add_entrys.get(i);
        }

        if(resultData.get("errors")==null || "".equals(resultData.get("errors"))) {
            //执行更新
            if (real_update_entrys.length > 0) {
                SaveServiceHelper.update(real_update_entrys);
            }
            //执行新增
            if (real_add_entrys.length > 0) {
                OperationResult result_submit = OperationServiceHelper.executeOperate("submit", "pznm_supplierzm",
                        real_add_entrys, OperateOption.create());
                if (result_submit.isSuccess() == true) {
                    OperationResult result_audit = OperationServiceHelper.executeOperate("audit", "pznm_supplierzm",
                            real_add_entrys, OperateOption.create());
                    if (result_audit.isSuccess() == false) {
                        resultData.put("errors", "子码审核失败");
                    }
                } else {
                    resultData.put("errors", "子码创建失败");
                }
            }
        }
    }

    private void doSetWtrEntry(List<Map> mapEntrys, Map resultData, DynamicObject supplierObj) {
        DynamicObjectCollection entrys = supplierObj.getDynamicObjectCollection("pznm_wtrentry");
        entrys.clear();
        for(Map mapEntry : mapEntrys){
            DynamicObject newEntry = new DynamicObject(entrys.getDynamicObjectType());
            //所属组织
            setDynamicField(true,"pznm_wtret_org_number","pznm_wtret_org","bos_org",
                    mapEntry,resultData,newEntry);
            //委托人信息.委托人电话
            setTextField(false,"pznm_wtret_userphone","pznm_wtret_userphone",mapEntry,resultData,newEntry);
            //委托人.编码
            setDynamicField(true,"pznm_wtret_user_number","pznm_wtret_user","pznm_outcontacts",
                    mapEntry,resultData,newEntry);
            entrys.add(newEntry);
        }
    }

    private void doSetKzztentry(List<Map> mapEntrys, Map resultData, DynamicObject supplierObj) {
        DynamicObjectCollection entrys = supplierObj.getDynamicObjectCollection("pznm_kzztentry");
        entrys.clear();
        for(Map mapEntry : mapEntrys){
            DynamicObject newEntry = new DynamicObject(entrys.getDynamicObjectType());
            //所属组织
            setDynamicField(true,"pznm_kzztet_org_number","pznm_kzztet_org","bos_org",
                    mapEntry,resultData,newEntry);
            //公司级状态
            setTextField(true,"pznm_companystatus","pznm_companystatus",mapEntry,resultData,newEntry);

            entrys.add(newEntry);
        }
    }

    /* 校验并设置F7字段
     * @key 入参校验字段
     * @fieldName 写入供应商对象的字段名
     * @entityNumber 字段对应基础资料实体名
     * @param 接口入参对象
     * @resultData 返回报文对象
     * @supplierObj 供应商对象
     */
    private void setDynamicField(Boolean isMust,String key,String fieldName, String entityNumber, Map param, Map resultData, DynamicObject supplierObj) {
        if(param.get(key)==null || "".equals(param.get(key))){
            if(isMust){
                String errors = resultData.get("errors")!=null?resultData.get("errors").toString()+";":"";
                resultData.put("errors",errors+"参数【" + key + "】必填");
            }
        }else{
            QFilter qFilter_number = new QFilter("number",QCP.equals,param.get(key));
            QFilter qFilter_enable = new QFilter("enable", QCP.equals,"1");
            QFilter qFilter_status = new QFilter("status", QCP.equals, "C");
            DynamicObject objCol = BusinessDataServiceHelper.loadSingleFromCache(entityNumber,"id,number,name",
                    new QFilter[]{qFilter_number,qFilter_enable,qFilter_status});
            if(objCol!=null){
                supplierObj.set(fieldName,objCol);
            }else{
                String errors = resultData.get("errors")!=null?resultData.get("errors").toString()+";":"";
                resultData.put("errors",errors+"参数【" + key + "】值【"+param.get(key)+"】匹配不成功，可能的原因是：1、编码不正确 2、不符合基础资料字段查询条件");
            }
        }
    }

    /* 校验并设置文本字段
     * @key 入参校验字段
     * @fieldName 写入供应商对象的字段名
     * @param 接口入参对象
     * @resultData 返回报文对象
     * @supplierObj 供应商对象
     */
    private void setTextField(Boolean isMust,String key,String fieldName,Map param, Map resultData, DynamicObject supplierObj) {
        if(param.get(key)==null || "".equals(param.get(key))){
            if(isMust){
                String errors = resultData.get("errors")!=null?resultData.get("errors").toString()+";":"";
                resultData.put("errors",errors+"参数【" + key + "】必填");
            }
        }else{
            supplierObj.set(fieldName,param.get(key));
        }
    }

    /* 校验并设置日期字段
     * @key 入参校验字段
     * @fieldName 写入供应商对象的字段名
     * @param 接口入参对象
     * @resultData 返回报文对象
     * @supplierObj 供应商对象
     */
    private void setDateField(Boolean isMust,String key,String fieldName,Map param, Map resultData, DynamicObject supplierObj) throws ParseException {
        if(param.get(key)==null || "".equals(param.get(key))){
            if(isMust){
                String errors = resultData.get("errors")!=null?resultData.get("errors").toString()+";":"";
                resultData.put("errors",errors+"参数【" + key + "】必填");
            }
        }else{
            supplierObj.set(fieldName,new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(param.get(key).toString()));
        }
    }
}