FXUI

# 新建编辑页JS插件

对象新建编辑页JS插件允许开发人员定制对象表单的相关功能。

# 简单示例

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore() {
        return Promise.resolve({
            title: 'pwc测试表单'
        })
    }
}

说明： 1、apply 用来声明钩子。例如此示例，插件声明了一个钩子，该钩子在列表页渲染之前调用。 2、renderBefore 是钩子的具体实现。例如此示例，钩子定义了表格渲染依赖的配置项：修改表单标题。

注意： 1、钩子需返回promise对象，意味着支持异步逻辑。

# 钩子

"钩子"（Hook）通常是指一种允许你在特定事件或状态发生时插入自定义代码的机制。

# form.render.before

该钩子在渲染对象表格之前调用

参数

  • context: Object
  • context.objApiName: String: 当前对象api_name
  • context.recordType: String: 当前数据的业务类型
  • context.type: 'clone|mapping|draft|edit|add': 表单来源类型
  • context.BaseComponents: {text, base, ...}: 插件内部可以基于它去扩展组件返回
  • context.masterData: Object: 当前对象主对象数据
  • context.details: Object: 当前从对象数据,不一定会有，仅当复制 映射 编辑等本来就带入从对象数据的时候会有

表单属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        return Promise.resolve({
            // 标题
            title: 'pwc测试表单',
            // 按钮
            button: {
                add: [{ // 增加按钮，触发事件写在回调中
                    action: 'form_button_1',
                    label: '自定义按钮1',
                    callback() {
                        alert('form_button_1');
                    }
                },{
                    action: 'form_button_2',
                    label: '自定义按钮2'
                }],
                reset: [{ // 重置按钮
                    action: 'form_button_3',
                    label: '自定义按钮3'
                }],
                del: ['cancel'] // 删除按钮
            },
            // 字段渲染，按字段扩展的主对象组件，详情见示例
            components: {
                [fieldApiName]: context.BaseComponents.base.extend({
                    ...
                })
            }
        })
    }
}

# form.render.after

该钩子发生在渲染视图之后

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.after",
                functional: this.renderAfter.bind(this)
            }
        ];
    }
    renderAfter(context) {
        // todo what you want
        return Promise.resolve();
    }
}

# form.submit.before

该钩子发生在点击提交触发提交逻辑前

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.submit.before",
                functional: this.submitBefore.bind(this)
            }
        ];
    }
    submitBefore(context) {
        // todo what you want
        return new Promise(function() {
            resolve()
        });
    }
}

# form.dataChange.after

该钩子发生在主对象字段变更之后 changeData：插件内可以直接修改该对象达到变更其他字段值的目的，底层最后根据changeData触发计算

参数

  • context: Object
  • context.changeData: Object: 变更的数据
  • context.oldData: Object: 老数据

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.dataChange.after",
                functional: this.dataChangeAfter.bind(this)
            }
        ];
    }
    dataChangeAfter(context) {
        // todo what you want
        return new Promise(function() {
            resolve()
        });
    }
}

# md.render.before

该钩子发生在从对象渲染之前

从表单属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.render.before",
                functional: this.mdRenderBefore.bind(this)
            }
        ];
    }
    mdRenderBefore(context) {
        // todo what you want
        return new Promise(function() {
            resolve({
                //隐藏指定字段
                //common表示该从对象的所有业务类型都隐藏
                //也可以指定业务类型 最终取并集
                hideFields: {
                    common: ['name'],
                    default__c: ['field_O4e6T__c']
                },
                // 过滤掉不需要批量编辑的字段
                filterBatchEditFields: ['price', 'discout'],
                // 改变字段的只读 必填
                // 如果字段被设为只读，页面表现为不可填写
                fieldsAttr: {
                      field_kh2rB__c: {
                          is_readonly: true | false
                          is_required: true | false
                      },
                      default__c: {
                          field_kbdfd__c: {
                              is_readonly: true | false
                              is_required: true | false
                          }
                      }
                },
                //单行操作按钮
                operateBtns: [function(){
                    return {
                        add: [{
                            label: '按钮1',
                            action: 'text_handle',//尽量唯一
                            callBack(trData, {objectApiName, recordType}) {}
                        }],
                        reset: [{ // 重置按钮
                            action: 'form_button_3',
                            label: '自定义按钮3'
                        }],
                        del: ['delRowHandle'],//不显示底层默认的按钮 delRowHandle[删除] copyRowHandle[复制] tileHandle[平铺]
                        retain: [], //仅保留指定action的按钮
                    }
                }],
                //通用按钮 表格右上角
                buttons: {
                    del: [],//预置的有Single_Add[添加一行],Import_Excel[从excel导入]
                    retain: [action]//仅保留指定action的按钮，如果按钮是从价目表明细添加，action的值是字段的值。例如['Single_Add', 'product_id'] 仅保留添加一行 从产品批量添加，  retain: []表示所有的按钮都不显示
                    add: [{
                        action: 'xxx_xx',//根据业务命名尽量要唯一
                        label: '测试按钮',
                        callBack(undefind, {objectApiName, recordType, $event}) {
                            alert($($event.target).text());
                        }
                    }],
                    //重置通用按钮的一些属性，目前支持label(按钮名称)改名
                    reset: {
                        Import_Excel: {
                            label: '导入'
                        },
                        Single_Add: {
                            label: '追加一行'
                        }，
                        product_id: {
                            label: 'xxxx',
                            callBack() {}
                        }
                    },
                    default__c: {//可以单独指定某种业务类型的按钮
                        add: []
                    },
                    outNum: 10 //可设置平铺按钮数量，底层默认3个
                },
                // 批量按钮 表格左上角 用法和buttons一样
                // 预置的action: tableBatchEditHandle(批量编辑) copySelectedHandle(复制)
                // delSelectedHandle(删除)
                batchButtons: [...],

                // 自定义列的render
                columnRenders: [{
                    name(cellValue, trData) {
                        return 'xxxx' + cellValue
                    }
                  },{
                    sex: {
                        //当name字段更新时，它也会重新调用
                        depend_fields: ['name'],
                        render(cellValue, trData) {
                            return '<span data-action="test"><span>' + cellValue
                        },
                        actionCallBacks: {
                            //opts = {column,$event,$target,data, next}
                            test(opts) {
                                opts.next({sex: '男'})
                            }
                        }
                    }
                }],
                fakeFields: [{
                    pos: 'after', //默认after 可不传
                    field_name: 'name',//在name字段后面插入一个自定义的字段
                    fields: [{
                        api_name: 'xxxxy__fake',
                        fixed: true, //如果此属性为true,会将此列固定到列表前面，不在name后面插入，比较适用icon列之类需要固定到前面的列
                         width: 56,
                         is_readonly: true,
                         label_html: '<span style="">s</span>',
                         render(cellValue, cellType, trData){
                            return '<span data-action="accountobj_history"></span><span data-action="accountobj_history2"></span>'
                         },
                        actionCallBacks: {
                            accountobj_history(trData, {objectApiName,recordType}) {alert(1)},
                            accountobj_history2() {alert(22)}
                        }  
                    }]
                }]
            });
        });
    }
}

# md.add.before

该钩子发生在添加一行之前

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.newData: Object: 新添加的行数据
  • context.dataIndex: String: 行数据rowId

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.add.before",
                functional: this.mdAddBefore.bind(this)
            }
        ];
    }
    mdAddBefore(context) {
        // todo what you want
        return new Promise(function() {
            resolve()
        });
    }
}

# md.batchAdd.before

该钩子发生在批量添加前

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.lookupField: Object: 批量添加场景选择的lookup字段

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.batchAdd.before",
                functional: this.mdBatchAdd.bind(this)
            }
        ];
    },
    mdBatchAdd(context) {
        // todo what you want
        return new Promise(function() {
            resolve({
                skipReadOnlyValidate: true, // 跳过只读校验，因为只读的字段，底层是不让选择的
                skipSearch: true, // 强制只能去弹框里选择，不能在当前页检索
                beforeRequest(rq) { // 请求数据之前处理参数
                    // 可以往rq里塞筛选条件
                    return rq;
                },
                fieldName: '',
                // 透传给选数据页面参数，注意通过插件执行参数中的preData获取前置插件返回值，合并后返回
                extendParam: {
                    // 处理获取价目表参数
                    formatPriceBookListParam: (data, options) => data
                }
            });
        });
    }
}

# md.batchAdd.after

该钩子发生在批量添加后

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.lookupDatas: Array: 批量添加场景，从选择组件选择的lookup对象的数据
  • context.lookupField: Object: 批量添加场景选择的lookup字段
  • context.newDataIndexs: Array: 将要新增的数据的索引

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.batchAdd.after",
                functional: this.mdBatchAdd.bind(this)
            }
        ];
    },
    mdBatchAdd(context) {
        // todo what you want
        return new Promise(function(context) {
            resolve({
                newDatas: [
                    {
                        name: '',
                        field_aa__c: '',
                    	...
                	},
                 	....
                ] //如果返回此参数，会用这里的数据覆盖底层添加的
            });
        });
    }
}

# md.copy.before

该钩子发生在复制前

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.copyRowIds: Array

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.copy.before",
                functional: this.mdCopyAdd.bind(this)
            }
        ];
    },
    mdCopyAdd(context) {
        // todo what you want
        return new Promise(function(context) {
            resolve({
            	parseParam(calParam) {
                    //复制数据，发起计算之前处理计算参数
                    return calParam
                }
            });
        });
    }
}

# md.copy.after

该钩子发生在复制后

# md.excelimport.before

该钩子发生在excel导入之前

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.excelimport.before",
                functional: this.mdExcelImport.bind(this)
            }
        ];
    },
    mdExcelImport(context) {
        // todo what you want
        return new Promise(function(context) {
            resolve({
            	importConfig: {
                    parseFormatDatas(formatDatas) {//再次格式化数据 是异步的promise
                        return Promise.resolve(formatDatas);
                    },

                    //过滤某些字段不能导入
                    // fieldList: [{id: 'name', label:'主属性'}]
                    filtersMappingFields(fieldList) {
                        return fieldList;
                    },
                    //底层对于不可编辑的字段是不允许导入的
                    //可以通过它来要求底层支持导入
                    forceImportFields: [''],

                    validateMappingFields(fieldList1, fieldList2){
                        return '' || '错误提示'
                    },
                    //过滤excel数据，比如可以过滤掉业务上认为为空的行数据
                    filterExcelDatas(excelDatas) {
                        return excelDatas
                    }
               	}
            });
        });
    }
}

# md.excelpaste.before

该钩子发生在从excel复制数据到单元格之前

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.fieldIsReadOnly: Boolean
  • context.fieldName: String

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.excelpaste.before",
                functional: this.mdExcelPasteBefore.bind(this)
            }
        ];
    },
    mdExcelPasteBefore(context) {
        // todo what you want
        return new Promise(function(context) {
            resolve({
            	supportPaste, // 默认只读字段都是屏蔽excel复制粘贴的，除非该参数为true
                noSupportPaste,
                pasteConfig: {
                    //过滤某些字段不能导入
                    filtersMappingFields(fieldList) {
                        return fieldList;
                    },
                    //过滤excel数据，比如可以过滤掉业务上认为为空的行数据
                    filterExcelDatas(excelDatas) {
                        return excelDatas
                    }
               	}
            });
        });
    }
}

# md.excelpaste.after

该钩子发生在从excel复制数据到单元格之后，已经解析完数据，准备做数据的更新和添加 钩子可直接操作pasteContend里的changeData和addDatas达到二次加工数据的目的

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.pasteContent: Object
  • context.pasteContent.changeData: 要更新的行数据
  • context.pasteContent.addDatas: 要添加的行数据
  • context.pasteContent.changeFields: 粘贴设计到的字段

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.excelpaste.after",
                functional: this.mdExcelpasteAfter.bind(this)
            }
        ];
    }
    mdExcelpasteAfter(context, objApiName, recordType, pasteContent) {
        // todo what you want
        return new Promise(function() {
            resolve()
        });
    }
}

# md.edit.before

该钩子发生在编辑单元格之前

参数

  • context: Object
  • context.objApiName: String: 当前变更数据的对象api_name
  • context.recordType: String: 当前变更数据的业务类型
  • context.fieldName: String: 触发编辑的字段名称
  • context.fieldNames: Array: 与fieldName互斥，仅当编辑的字段有依赖关系（如国家省市区，或三角关系的lookup字段），一次编辑同时编辑几个字段，使用时尽量先判断有无fieldNames
  • context.dataIndex: Array: 修改的数据索引 批量编辑多条数据时，可能有多个值
  • context.isClean: Boolean: 当前编辑是否是清空操作

属性：

export default class Plugin {
    apply() {
        return [
            {
                event: "md.excelpaste.after",
                functional: this.mdExcelpasteAfter.bind(this)
            }
        ];
    }
    mdExcelpasteAfter(context) {
        // todo what you want
        return new Promise(function() {
            resolve({
                skipSearch: true,//跳过检索，强制弹框选数据,此属性仅当编辑的字段是lookup是生效
                modulePath: 'xx/xx',//选对象的模块，可以不传，
                beforeRequest(rq) {return rq},

                options: [{label: 'xx', value: 'xx'}],//单选多选字段，只能选择传的选项

                //可以用这两个参数改变要选择的对象
                apiname: 'SalesOrderdsfdObj',
                relatedname: 'target--xxxxx',
                // 透传给选数据页面参数，注意通过插件执行参数中的preData获取前置插件返回值，合并后返回
                extendParam: {
                    // 处理获取价目表参数
                    formatPriceBookListParam(data, options) => data
                }，

                //接管字段的编辑
                fieldEditCallBack() {
                    return new Promise(resolve => {
                        //你的逻辑
                        //底层只关心你都变了那些数据，怎么变的，怎么选的不关心
                        //changeData: {account_id: '12323213',account_id__r: '测试数据'， lookupData: {......}},如果当前编辑的字段是查找关联字段，尽量把lookupData，也就是你选的那条数据传过来

                        //注意：无论任何情况必须执行resolve
                        //如果本身没变更数据或发生错误 直接resove()即可
                        resolve(changeData)
                    })
                }
            });
        });
    }
}

# 上下文

上下文（Context）通常是指特定事件或状态发生时提供的参数（特定和通用）和API（特定和通用）的集合。

注意：dataUpdater 的所有API执行完还需要额外的触发一次context.end()才能生效。

# dataGetter.getDescribe()

获取当前对象的对象描述

参数

  • apiName: String: 对象apiname（可不传，默认当前表单对象）

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let describe = context.dataGetter.getDescribe();
        console.log(describe);
        return Promise.resolve();
    }
}

# dataGetter.getDescribeLayout()

透传describeLayout接口完整返回值

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let describeLayout = context.dataGetter.getDescribeLayout();
        
        console.log(describeLayout);

        return Promise.resolve();
    }
}

# dataGetter.getData()

获取当前对象的对象数据

参数

  • apiName: String: 对象apiname（可不传，默认当前表单对象）
  • dataIndex: String: 从对象行rowId（获取主对象数据可不传）

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let data = context.dataGetter.getData();
        
        console.log(data);

        return Promise.resolve();
    }
}

# dataGetter.getFieldAttr()

获取对象（主对象/从对象）下某个字段的详细信息

参数

  • fieldName: String: 字段apiname（必填）
  • apiName: String: 对象apiname（必填）

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let fieldInfo = context.dataGetter.getFieldAttr('field_22at2__c', 'object_aaa__c'); // 获取对象的字段描述

        console.log(fieldInfo);
        
        return Promise.resolve();
    }
}

# dataGetter.getLayoutFields()

获取当前对象下，对象布局显示的字段完整描述

参数

  • apiName: String: 对象apiname（可不传，默认当前对象，从对象需要传）
  • recordType: String: 对象业务类型（从对象需要传）

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let layoutfields = context.dataGetter.getLayoutFields('default__c');

        console.log(layoutfields);

        return Promise.resolve();
    }
}

# dataGetter.getDataIsNew()

判断从对象数据是否是插件执行过程中新增的

参数

  • rowId: String: 从对象行数据rowId（必传）

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let isNew = context.dataGetter.getDataIsNew('1693377736231368');

        console.log(isNew);

        return Promise.resolve();
    }
}

# dataGetter.getDetails()

获取当前对象下所有从对象的数据

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let dataDetails = context.dataGetter.getDetails();

        console.log(dataDetails);

        return Promise.resolve();
    }
}

# dataGetter.getDetail()

获取当前对象下指定从对象的全部数据

参数

  • apiName: String: 从对象apinme（必传）

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let detailData = context.dataGetter.getDetail('object_22at2__c');

        console.log(detailData);

        return Promise.resolve();
    }
}

# dataGetter.getMasterData()

获取当前主对象数据

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        let masterData = context.dataGetter.getMasterData();

        console.log(masterData);

        return Promise.resolve();
    }
}

# dataUpdater.add()

添加从对象数据

参数

  • options: Object: 添加从对象数据的信息

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.add([{
            object_describe_api_name: '', //必填
            record_type: '', //必填
            ...
        }, ...]); // 省略的数据自行补充
        context.end();
        return Promise.resolve();
    }
}

# dataUpdater.del()

删除某个从对象的指定行数据

参数

  • apiName: String: 从对象apiname
  • rowId: String: 要删除单行数据的rowId

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.del('field_22at2__c', '1693377736231368');
        context.end();
        return Promise.resolve();
    }
}

# dataUpdater.delDetail()

删除某个从对象的数据

参数

  • apiName: String: 从对象apiname

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.delDetail('field_22at2__c');
        context.end();
        return Promise.resolve();
    }
}

# dataUpdater.delDetailAndTrigger()

删除某个从对象的数据并触发相关计算

参数

  • apiName: String: 从对象apiname

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.delDetailAndTrigger('field_22at2__c');
        context.end();
        return Promise.resolve();
    }
}

# dataUpdater.delDetailRecordType()

删除某个业务类型表格数据

参数

  • apiName: String: 从对象apiname
  • recordType: String: 从对象业务类型

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.delDetailRecordType('object_22at2__c', 'recordtype__c');
        context.end();
        return Promise.resolve();
    }
}

# dataUpdater.insert()

在指定行下插入数据

参数

  • apiName: String: 从对象apiname
  • insertRowId: String: 指定行rowId
  • datas: Object: 要插入的数据

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.delDetailRecordType('object_22at2__c', '1693377736231368', {
            record_type: 'default__c', // 必填
            name: '',
            ...
        });
        context.end();
        return Promise.resolve();
    }
}

# dataUpdater.setHidden()

隐藏字段。

注意：该方法需要在渲染后钩子中执行才可生效，因此不能使用在form.render.before、md.render.before钩子中。

参数

  • param: Object
  • param.dataIndex: Array: 指定行rowId组成的数组，修改单行数据可传字符串，主对象不需要传
  • param.status: Boolean:
  • param.fieldName: Array: 与rowId数组对应的行要隐藏的字段apiname

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.setHidden({
            dataIndex: ['1693377736231368'],
            status: true,
            fieldName: ['field_22at2__c']
        });
    	context.end();

        return Promise.resolve();
    }
}

# dataUpdater.setReadOnly()

设置某个对象的某个字段为只读或非只读状态

注意：该方法需要在渲染后钩子中执行才可生效，因此不能使用在form.render.before、md.render.before钩子中。

参数

  • param: Object
  • param.dataIndex: String|Array: 指定行rowId组成的数组，修改单行数据可传字符串，主对象不需要传
  • param.status: Boolean:
  • param.fieldName: String|Array: 与rowId数组对应的行要修改的字段apiname

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.setReadOnly({
            dataIndex: ['1693377736231368'],
            status: true,
            fieldName: ['field_22at2__c']
        });
    	context.end();

        return Promise.resolve();
    }
}

# dataUpdater.setRequired()

注意：该方法需要在渲染后钩子中执行才可生效，因此不能使用在form.render.before、md.render.before钩子中。

设置字段必填

参数

  • param: Object
  • param.dataIndex: String|Array: 指定行rowId组成的数组，修改单行数据可传字符串，主对象不需要传
  • param.status: Boolean:
  • param.fieldName: String|Array: 与rowId数组对应的行要修改的字段apiname

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.setRequired({
            dataIndex: ['1693377736231368'],
            status: true,
            fieldName: ['field_22at2__c']
        });
    	context.end();

        return Promise.resolve();
    }
}

# dataUpdater.updateDetail()

更新从对象数据

参数

  • apiName: String: 要更新数据从对象的apiname
  • rowId: Boolean: 从对象行rowId
  • objData: Object: 要更新的数据

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.updateDetail('object_22at2__c', '1693377736231368', {
            'name': '1111',
            'record_type': 'default__c'
        });

        context.end();

        return Promise.resolve();
    }
}

# dataUpdater.updateMaster()

更新主对象数据，不会触发字段变更，可以手动调用 triggerCalAndUIEvent 函数触发字段变更

参数

  • objData: Object: 要更新的数据

示例：

export default class Plugin {
    apply() {
        return [
            {
                event: "form.render.before",
                functional: this.renderBefore.bind(this)
            }
        ];
    }
    renderBefore(context) {
        context.dataUpdater.updateMaster({
            'name': '1111'
        });

        context.end();

        return Promise.resolve();
    }
}

# triggerCalAndUIEvent

触发计算和UI事件

参数

  • options: Object
  • options.changeFields: Array：表示此次计算是因为修改了xx引起的(必传)

示例：

context.triggerCalAndUIEvent({changeFields: ['price', 'num']})

# triggerUIEvent

触发UI事件

参数：

  • options: Object
  • options.objApiName: String：当前发起计算的对象(可选)

示例：

context.triggerUIEvent({objApiName: 'object_dQ8rr__c'})

# triggerCal

触发计算

参数：

  • options: Object
  • options.objApiName: String：当前发起计算的对象(可选)

示例：

context.triggerCalculate({objApiName: 'object_dQ8rr__c'})

# UI

UI事件

属性：

{
    //隐藏某个从对象表格 如果不传业务类型，则整个从对象都被隐藏
    hideDetailsComp(objApiName, recordType),

    //显示某个从对象表格 如果不传业务类型，则整个从对象都被显示     
    showDetailsComp(objApiName, recordType),

    //隐藏从对象表格上的指定列,如果不传业务类型，则隐藏所有
    hideColumns(fieldNames, objApiName, recordType), // hideColumns(['name', 'sex'], 'xxxx', 'default__c')

    //显示从对象表格上的指定列
    showColumns(fieldNames, objApiName, recordType),

    //设置某行的样式 setTrsCss(rowId, {background: 'red'});setTrsCss(rowId, {background: ''});
    setTrsCss(){},
}

# formType

获取新建来源

# recordType

返回当前表单业务类型

# 其他

新建编辑页JS插件（旧版）地址

lastUpdate: 10/30/2023, 4:58:58 PM

← 列表页JS插件 →