uicore-web
Version:
web ui core
791 lines (784 loc) • 34.9 kB
JavaScript
import {getToken} from "../../utils/auth";
import common from "./common";
/**
* 已正式加入框架体系应用
* marked by deleteelf 20210713
*/
export default {
mixins: [common],//监听外部框架的大小改变事件
data() {
return {
loaded: false,
columnSize: 12,
formMap: {},
form: {
novali:[]
},
items: [],//表单项
rules: {},//验证规则
itemParams:{}
}
},
components:{
RichEditor: (resolve) => require([`../RichEditor`], resolve),
},created() {
},
methods: {
async updateForm(formItems,formData) {
this.columnSize = 24 / ((this.options.columnCount > 4 ? 4 : this.options.columnCount) || 2);//最大只允许4
if(!formItems)
formItems=this.items;
await this.initFormItem(formItems,formData);
this.loaded = true;
},async initFormItem(formItems, formData=[]) {
this.$d.debug().log("初始化表单");
this.formMap={};
for (let j=0;j<formItems.length;j++) {
let item = formItems[j];
this.formMap[item.code] = j;
let data = item.value != null ? item.value : item.defaultValue;
if (data) {
let tmp = data;
if (typeof tmp == "string" && tmp.indexOf("{") >= 0) {
tmp = tmp.urlFormat(this.form, true, true);
}
if (tmp)
tmp = this.$d.adapterData(tmp);
this.$set(this.form, item.code, tmp);
} else {
switch (item.type) {
case "image":
case "file":
case "transfer":
if (!data)
data = [];
break;
case "stepusers":
data = [];
break;
default:
data = "";
break;
}
this.$set(this.form, item.code, data);
}
}
for (let key in this.options.params) {//不论是否新增,都需要从地址栏获取传入参数
if (this.options.params[key])
this.form[key] = this.options.params[key];
}
formItems.forEach((item)=> {
if (item.linkageRule && typeof item.linkageRule == "string")
item.linkageRule = this.$d.adapterData(item.linkageRule);
if (item.url) {//尝试先从地址协议上获取配置规则
let params = this.$d.getParams(item.url);
let rule = {};
let keys = ["supportNullSelect", "triggers", "datas", "chooseShow", "always", "checkStrictly", "multiple"];
for (let k = 0; k < keys.length; k++) {
let key = keys[k];
if (params[key]) {
switch (key) {
case "triggers":
rule[key] = params[key].split(",");
break;
case "datas":
let names = params[key].split(",");
rule[key] = {};
for (let index in names) {
if (names[index])
rule[key][names[index]] = "{" + names[index] + "}";
}
break;
default:
rule[key] = this.$d.adapterData(params[key]);
break;
}
delete params[key];
}
}
if (Object.getOwnPropertyNames(rule).length > 0) {
item.linkageRule = this.$d.merge(rule, item.linkageRule);//融合参数支持
item.url = this.$d.replaceQueryString(this.$d.getPageAddress(item.url), params, false, true);//裁剪掉相关参数
}
if (item.always != null) {//如果配置了属性，则数据具备最高优先级
item.linkageRule = this.$d.merge(item.linkageRule, {always: item.always});//融合参数支持item.always;
}
}
});
//加载表单数据
let formMap = this.formMap;
for (let i=0;i<formData.length;i++) {
let item = formItems[formMap[formData[i].name]];
// this.$d.debug().log(item,formData[i].val);
if (formData[i].val) {
switch (item.type) {
case "text":
case "textarea":
case "sql":
case "html":
case "xml":
case "json":
if (typeof formData[i].val == "object")
this.$set(this.form, formData[i].name, JSON.stringify(formData[i].val));
else
this.$set(this.form, formData[i].name, formData[i].val);
break;
case "image":
case "file":
case "transfer":
case "stepusers":
case "transfer":
let data=this.$d.adapterData(formData[i].val);
if(this.$d.isArray(data)){
this.$set(this.form, formData[i].name, data);
}else{
this.$d.debug().warn("数据格式错误,强制修正!!!,需求数据为数组,目标数据为:",data);
this.$set(this.form, formData[i].name, []);
}
break;
case "editor":
this.$set(this.form, formData[i].name, this.$d.resameUrl(this.$store.state.api.axios.baseURL,formData[i].val));
break;
default:
this.$set(this.form, formData[i].name, this.$d.adapterData(formData[i].val));
break;
}
}else {//某些字段数据格式有要求，需要进行适配
if (item) {
switch (item.type) {
case "image":
case "file":
case "transfer":
case "stepusers":
case "transfer":
//如果不是有效的结果值，则维持原来的默认值
this.$set(this.form, formData[i].name, []);
break;
default://空字符串也是有效值
this.$set(this.form, formData[i].name, "");
break;
}
} else {
this.$d.debug().warn("item为空", formData[i].name, formMap);
}
}
}
//验证逻辑需要最后来加载，否则会报错
if (this.options.params.readonly !== true) {//页面处于只读状态时，无需加载验证规则
for (let i in formItems) {
let item = formItems[i];
if (item.isEmpty===false) {
this.setRequiredRule(item);
}else if(item.required) {
this.setRequiredRule(item);
}
let regex=item.validateRegex||item.regex;
if (regex) {
if (!this.rules[item.code]) {
this.$set(this.rules, item.code, []);
}
//兼容早期的eval
let rule = {
pattern: new RegExp(regex.replaceAll("\\\\", "\\")),
message: this.$_i18n(item.message||item.msg), trigger: 'blur'
};
this.rules[item.code].push(rule);
}
item.rule = this.rules[item.code];
}
}
this.items = formItems;
//对表单进行恢复视图
for (let i in formItems) {
let item = formItems[i];
switch (item.type) {
case "date":
case "datetime":
case "text":
case "textarea":
case "switch":
if (item.url) {
item.triggerHandler = async (formItem, val=undefined) => {//如果后续需要变化，是根据某些组件联动来实现的
if (this.loaded&&val!==undefined) {//加载完成才能触发值改变
this.$set(this.form, formItem.code, val);
}
let options = this.$d.extend({}, this.options.params, this.form);
let url = formItem.url.urlFormat(options, false, true);
await this.$async({url: url, keymap: {}}).then(async (res) => {
for(let i in res.data){
item.datas= res.data[i];
for (let key in res.data[i]){
if(key=="searchtime"){
this.changed(new Date(res.data[i][key]).format(item.formatString), item);
}else{
if(item.type=="switch"&&typeof res.data[i][key]!="boolean"){
let result=false;
if(this.$d.adapterData(res.data[i][key]))
result=true;
this.changed(result, item);//只对第一个值进行接收，所以不建议传递多值回来，如果需要传递多值，又能正确给值，建议
break;
}
//只对第一个值进行接收，所以不建议传递多值回来，如果需要传递多值，又能正确给值，建议使用带字段排序支持的json体
this.changed(res.data[i][key], item);
break;
}
}
}
});
}
//默认情况下只有新增数据才会加载默认值，除非是加了always
if( (!this.options.params.id&&!item.value) ||(item.linkageRule&&item.linkageRule.always)||this.form[item.code]===undefined){//如果没有默认值，才进行数据加载
await item.triggerHandler(item);
}
}
break;
case "content":
case "section":
item.content=item.defaultValue||item.name;
if (item.url && !this.form[item.code]) {//如果没有默认值，才进行时间数据加载，这2个控件都是富文本类型的，要考虑可能不是json
let options = this.$d.extend({}, this.options.params, this.form);
await this.$async({url: item.url.urlFormat(options,false)}).then(async (res) => {
item.content=res;
});
}
break;
case "select"://下拉
case "dropdownchecklist"://多选下拉
case "autocomplete"://自动完成
case "autocomplete_remote"://自动完成
case "checkbox"://自动完成
case "cascader"://级联
//expandTrigger="hover"
//multiple = true 开启多选 checkStrictly 关闭级联选择
//lazy=true lazyload=function（）开启懒加载
case "transfer"://穿梭
case "processlist"://流程组件
case "steplist"://流程步骤组件
case "radio"://单选组件
if(item.type=="radio") {
this.$set(item,"options",this.booleanArray(item));
// item.options = this.booleanArray(item);
if(item.options.length)//如果配置了默认值，则不再执行远程加载
break;
}
if (item.type == "cascader" || item.type == "transfer") {
item.config = this.$d.merge({showFilter: true,key: "id",label: "name",value: "id"},
item.linkageRule || {});
} else {
item.linkageRule = this.$d.merge({}, item.linkageRule);
}
if (item.type == "processlist") {
await this.getProcessList(item, this.options.params.cid);
} else if (item.type == "steplist") {
item.linkageRule = this.$d.merge({triggers: ["users"],always:true,params:{ users:{url:"{url}",
allowChange:"{allow_change}"}}},item.linkageRule);
this.$d.debug().warn("步骤组件自动初始化联动目标users");
if(this.options.type=="workflow")
await this.getStepList(item);
else
await this.getProcessFirstStep(item);
}else {
if (item.url) {
item.triggerHandler = async (formItem, val=undefined) => {
this.$set(formItem, "options", []);
if (this.loaded&&val!==undefined) {//加载完成才能触发值改变
this.$set(this.form, formItem.code, val);
}
let options = this.$d.extend({}, this.options.params, this.form);
if(item.type=="autocomplete_remote"){
options.q=this.form[item.code];
}
let url = formItem.url.urlFormat(options, false, true);
let keymap = {};
if(item.linkageRule&&item.linkageRule.keymap)
keymap=item.linkageRule.keymap;
await this.$async({url: url, keymap: keymap}).then(async (res) => {
let data = res.data;
if (item.type == "cascader") {//只有级联数据需要转成树
data = this.$d.transform2TreeData(data, item.config.rootId || 0);
}
this.updateSelect(url, formItem, data);
});
}
await item.triggerHandler(item);
}
}
break;
case "stepusers"://步骤用户选择组件
item.config = this.$d.merge({showFilter: true,key: "id",label: "name",value: "id"},
item.linkageRule || {});
if(this.form.toStepId!=0)
this.setRequiredRule(item);
await this.getDefaultUsers(item);
item.dataUrl=this.$store.state.api.oa.getUsers;
item.triggerHandler = async (formItem, val=undefined) => {
this.$set(formItem, "options", []);
if (this.loaded && val !== undefined) {//加载完成才能触发值改变
this.$set(this.form, formItem.code, val);
}
let options = this.$d.extend({}, this.options.params, this.form);
let url = formItem.dataUrl.urlFormat(options, false, true);
let keymap = {};
if (item.linkageRule && item.linkageRule.keymap)
keymap = item.linkageRule.keymap;
await this.$async({url: url, keymap: keymap}).then(async (res) => {
let data = res.data;
this.updateSelect(url, formItem, data);
});
}
await item.triggerHandler(item);
break;
case "image":
case "file":
let rule = {
limit: 5, accept: "image/png,image/jpeg,image/apng,image/bmp,image/gif",
maxSize: 1024 * 512, desc: "只能上传jpg/png文件，且不超过500KB"
};
rule.data = {
app_id: this.$store.getters.appId, access_token: this.$store.getters.accessToken,
token: getToken()
}
if (item.type !== "image") {
rule.maxSize = 1024 * 1024 * 20;
rule.desc = "文件大小不超过20MB";
rule.accept = "";
}
item.linkageRule = this.$d.merge(rule, item.linkageRule);
if (item.url) {
item.url=this.$d.resameUrl(this.$store.state.api.axios.baseURL,item.url);
// if (!this.$d.isExternal(item.url)) {
// item.url = this.$store.state.api.axios.baseURL + item.url;
// }
// } else {
// item.url = this.$store.state.api.upload;
}
break;
case "editor":
item.config = this.$d.merge({readonly: this.checkDisable(item)}, item.linkageRule);
break;
default:
break;
}
}
return formItems;
// this.items = formItems;
// //传递由地址过来的值用于覆盖结果
// this.loaded = true;
},async changed(data, item) {
// this.$d.debug().log("探测到值改变事件",data,item);
//如果需要拦截数据改变,在这边做
this.form[item.code] = data;
if (item && item.linkageRule) {
if(this.loaded||item.linkageRule.always) {//常规模式下，表单初始化加载并不进行数据联动，仅当配置了always后，才会一直实时同步
let dataObj = null;
if (item.options) {//说明是下拉类的数据
for (let i in item.options) {
if (item.options[i].id == data) {
dataObj = item.options[i];
break;
}
}
}
if (item.datas) {//对文本类注入的数据也进行支持
dataObj = item.datas;
}
let rule = item.linkageRule;
let params = this.$d.extend({}, this.form, dataObj);
if (rule.params) {//增加对联动参数的支持
for (let targetItem in rule.params) { //因为加载顺序的问题，这个时间组件还不存在
if (!this.itemParams[targetItem])
this.itemParams[targetItem] = {};
for (let key in rule.params[targetItem]) {
if (typeof rule.params[targetItem][key] == "string")
this.itemParams[targetItem][key] = this.$d.adapterData(rule.params[targetItem][key].urlFormat(params, true, false));
else
this.itemParams[targetItem][key] = rule.params[targetItem][key];
}
}
}
// this.$d.debug().log("收到值改变事件",item.code,this.form, this.options.params, data, item);
await this.linkageData(rule, this.loaded, this.form, params);
//todo:这里还有一种需求,当部分数据变更时，需要改变一些组件的显示状态
//要求，该组件的数据中，就包含了需要隐藏与显示的字段，hide:[],show:[]
if (rule.chooseShow == true && item.options) {//除非要求选择显示功能打开
let dataItem = null;
for (let i in item.options) {
if (item.options[i].id == data) {
dataItem = item.options[i];
break;
}
}
if (dataItem) {
if (dataItem.hide) {
if (typeof dataItem.hide == "string")
dataItem.hide = this.$d.adapterData(dataItem.hide);
this.handleShow(dataItem.hide, false);
}
if (dataItem.show) {
if (typeof dataItem.show == "string")
dataItem.show = this.$d.adapterData(dataItem.show);
this.handleShow(dataItem.show, true);
}
}
}
}
}
},async getProcessList(formItem,cid){ //此方法属于oa的专有扩展属性，用于支持processlist组件
let url=this.$store.state.api.oa.getCategoryProcessList;
await this.$async({url: url, keymap: {},data:{cid:cid}}).then(async (res) => {
let data = res.data;
if(res.data.length) {//如果有数据，则设置必填
this.setRequiredRule(formItem);
}else {//如果没有加载流程列表,说明没有配置流程列表,则不用显示
formItem.isVisible = false;
}
this.updateSelect(url, formItem, data);
});
}, async getDefaultUsers(item, data = []) {
let options = this.$d.extend({}, this.options.params, this.form);
if(options.toStepId) {
//如果配置了专属默认用户来源则最高优先，其次表单重写，否则使用流程默认用户
let url=(this.itemParams["users"]&&this.itemParams["users"].url)||item.url||this.$store.state.api.oa.getStepDefaultUsers;
url = url.urlFormat(options, false, true);
await this.$async({url:url, data: {toStepId:options.toStepId}})
.then(async (res1) => {
if (!this.itemParams["users"]||this.itemParams["users"].allowChange!==true) {//如果允许修改，则新增只读关闭
item.disable = true;
this.$d.debug().log("步骤禁止修改审批人！！");
if(res1.data.length==0) {
this.$d.debug().warn("流程因没有配置有效的步骤用户，强制激活可配功能！");
item.disable = false;
}
}else{
item.disable = false;
}
if(item.disable) {
item.values = res1.data;
}
for (let j in res1.data) {
if (res1.data[j] && res1.data[j].id)//追加有效的默认审批人
data.push(res1.data[j].id)
}
await this.getStepUsers(item,data);
})
item.isVisible=true;
}else{
item.isVisible=false
}
return data;
}, async getStepUsers(item, defaultUsers= []) {
let toStepId=this.form.toStepId|| this.options.params.toStepId;
let infoId=this.form.infoId|| this.options.params.infoId;
let data=[];
await this.$async({url: this.$store.state.api.oa.getStepUsers, data: {toStepId:toStepId,infoId:infoId}})
.then(async (res1) => {
for (let j in res1.data) {
if (res1.data[j] && res1.data[j].id)//追加有效的默认审批人
data.push(res1.data[j].id)
}
if(item.disable){
if(res1.data.length>0)
item.values=res1.data;
}
if(data.length)
this.$set(this.form,item.code,data);
else
this.$set(this.form,item.code,defaultUsers);
})
return data;
},async getStepList(formItem){ //此方法属于oa的专有扩展属性，用于支持steplist组件
let url=this.$store.state.api.oa.getStepOptions;
await this.$async({url: url, keymap: {},data:{stepId:this.form.stepId}})
.then(async (res) => {
let data = res.data;
if(data.length>0) { //如果有数据，则设置必填
this.setRequiredRule(formItem);
}else{
this.clearRequiredRule(formItem);
}
this.$set(formItem,"disable",data.length<=1);
this.updateSelect(url, formItem, data);
});
},async getProcessFirstStep(formItem){ //此方法属于oa的专有扩展属性，用于支持steplist组件
let url= this.$store.state.api.oa.getProcessFirstStep;
await this.$async({url:url,data: {proId: this.form.proId}, keymap: {}})
.then(async (res) => {
let data = res.data;
if(data.length>0) {//如果有数据，则设置必填
this.setRequiredRule(formItem);
}else
this.clearRequiredRule(formItem);
this.$set(formItem,"disable",data.length<=1);
this.updateSelect(url, formItem, data);
});
},setRequiredRule(item) {
if (!this.rules[item.code]) {
this.$set(this.rules, item.code, []);
}
this.rules[item.code].push({
required: true,
message: this.$_i18n(item.name) + this.$t('form.required'), trigger: 'blur'
});
},clearRequiredRule(item){
let rule=this.rules[item.code];
if(rule){
for(let i in rule){
if(rule[i].required===true) {
rule[i].required = false;
break;
}
}
}
},checkDisable(item) {
if (this.options.params.readonly) {
return true;
}else if(item.disable===true) {//业务干预 //某些情况下，需要由代码业务逻辑来控制禁用
return true;
}else if(item.readonly===true){//业务干预 //某些情况下，需要由代码业务逻辑来控制只读
return true;
} else {
if (this.options.params.id) {
return item.modReadonly;
} else {
return item.addReadonly;
}
}
return false;
},isArrayControl(item){
return item.type == "dropdownchecklist" || item.type == "file" || item.type == "image" ||
item.type == "stepusers"||item.type=="transfer"||
(item.type == "cascader" && item.linkageRule && item.linkageRule.emitPath !== false);
},isTextControl(item){
return item.type == "text" || item.type == "password" || item.type == "json" ;
},updateSelect(url, item, data=[]) {
for (let i in data) {//针对部分数据可能是json的适配
data[i].id = this.$d.adapterData(data[i].id);
}
item.options = data;
if (item.linkageRule&&item.linkageRule.supportNullSelect === true) {
item.options.unshift({id: "", name: "请选择"});//插入到第一条
}
if (item.options&&item.options.length > 0) {
if (this.form[item.code]) {//如果有值尝试还原
if (this.isArrayControl(item)) {
if (!this.$d.isArray(this.form[item.code])) {//数据结果里，如果不是数组，则认为值无效
this.form[item.code] = [];
} else {//否则需要检查目前的结果值是否在可选范围
if(item.type=="dropdownchecklist") {//多选下拉才需要从结果回复视图
let re = this.form[item.code].filter((val) => item.options.find((op) => op.id == val));
this.form[item.code] = re;
}
}
}
} else {//多选和模糊搜索，需要用户自己选择
if (item.type == "select" || item.type == "steplist" || item.type == "processlist") {//如果下拉没有默认数据，则自动选择第一个
this.$set(this.form, item.code, item.options[0].id);
} else if (item.type == "dropdownchecklist" || item.type == "file" || item.type == "image" ||
(item.type == "cascader" && item.linkageRule && item.linkageRule.emitPath !== false)) {
if (!this.$d.isArray(this.form[item.code])) {//数据结果里，如果不是数组，则认为值无效
this.form[item.code] = [];
}
}
}
this.changed(this.form[item.code], item);
} else {
this.changed(null, item);
}
},booleanArray(item) {
// if(!item.formatString)
// item.formatString=item.booleanText;
if (!item.url&&!item.formatString)//如果bool
item.formatString = "是|否";
let result = [];
if(item.formatString) {
let temp = item.formatString.split("|");
for (let i in temp) {
result.push({id: i == 0, name: temp[i]});
}
}
return result;
},async linkageData(rule,loaded,result,params){
//触发需要改变的控件,需要判断控件是否已经加载
//工具栏没有加载完成时，加载过程逻辑会自动执行对应最新数据获取
//工具栏加载完成时，需要手动触发对应的控件进行重新加载
if (loaded||(rule &&(rule.always||rule.chooseShow))) {
if (rule.datas) { //触发需要改变的值
for (let key in rule.datas) {
let targetItem = this.items[this.formMap[key]];
if (loaded&&targetItem&&targetItem.type == "stepusers") {
let data = [];
await this.getDefaultUsers(targetItem, data);
this.$set(result, key, data);
} else {
if(typeof rule.datas[key]=="string"&&rule.datas[key].indexOf("{")>=0) {
let val=rule.datas[key].urlFormat(params, true, true);
if(targetItem && this.isArrayControl(targetItem)&&typeof val=="string"){
this.$set(result, key,val.split(","));//如果联动的目标是个数组，则进行数据切割
}else {
if(this.isTextControl(targetItem))
this.$set(result, key,val);
else
this.$set(result, key,this.$d.adapterData(val));
}
}else
this.$set(result, key, rule.datas[key]||params[key]);
}
}
}
if (rule.triggers) {
for (let i in rule.triggers) {
let formItem = this.items[this.formMap[rule.triggers[i]]];
if (formItem) {
if (formItem.triggerHandler) {
await formItem.triggerHandler(formItem);
// } else {
// this.$nextTick(() => { //触发点击事件
// this.handleClick(formItem);
// })
}
}
}
}
}
}, beforeUpload(file, item) {
if (file) {
if (file.size > item.linkageRule.maxSize) {
this.$message.error(item.linkageRule.desc);
return false;
}
return true;
}
return false;
}, handleExceed(files, fileList, item) {
this.$message.warning(`当前限制只能上传${item.linkageRule.limit}个文件，本次选择了${files.length}个文件，已上传${fileList.length}个文件`);
}, beforeRemove(file, fileList) {
if(file.status=="ready")//因上传验证失败的会处于准备就绪的状态，上传成功的都是success的状态
return true;
return this.$confirm(`确定移除 ${file.name}？`);
}, handleUploadSuccess(response, file, fileList, item) {
let url = response.url;
// if (!this.$d.isExternal(url))
// url = this.$store.state.api.axios.baseURL+"/" + response.url;
this.form[item.code].push({name: response.name, url: url, uid: file.uid, status: file.status,
id:response.id,userName:response.uname,userId:response.uid,type:response.type,
time:new Date(response.time||file.uid).format("yyyy-MM-dd HH:mm:ss")});
// this.handleFileChanged(file,fileList,item);
this.$d.debug().log("上传成功", response, file, fileList, item, this.form[item.code]);
}, handleUploadError(response, file, fileList, item) {
this.$d.debug().log("上传失败，如果需要处理，请优化", response, file, fileList, item, this.form[item.code]);
}, handleUploadRemove(file, fileList, item) {
for (let i in this.form[item.code]) {
if (this.form[item.code][i].uid == file.uid) {
this.removeItem(item,i);
break;
}
}
this.$d.debug().log("删除成功", file, fileList, this.form[item.code]);
}, handleRemote(query, item) {
this.$set(item, "loading", true);
if (item.timeoutHandler) {
clearTimeout(item.timeoutHandler);
item.timeoutHandler = null;
}
item.timeoutHandler = setTimeout(() => {
let options = this.$d.extend({}, this.options.params, this.form, {q: query});
let url = item.url.urlFormat(options, false, true);
this.$http({url: url}).then(async (res) => {
item.loading = false;
this.updateSelect(url, item, res.data)
});
}, 300);//延迟300毫秒，在快速输入时，减少交互
}, handleShow(items, isShow) {
if (!this.loaded) {
setTimeout(this.handleShow, 50, items, isShow);
return;
}
for (let i in items) {
this.items[this.formMap[items[i]]].isVisible = isShow;
let index = this.form.novali.findIndex((col) => col == items[i]);
if (isShow) {//加入验证
if (!this.rules[items[i]] && this.items[this.formMap[items[i]]].rule)
this.rules[items[i]] = this.items[this.formMap[items[i]]].rule;
if (index > -1)
this.form.novali.splice(index, 1);
} else {//移除验证
delete this.rules[items[i]];
if (index == -1)
this.form.novali.push(items[i]);
}
}
},checkVisible(item){ //此方法重写了page.js的方法，如果以后需要性能提升时，分离stepview和formview的页面逻辑
return item.isVisible!==false&&item.type!=='hidden';
},placeholderAdapter(item) {
if(!this.form.readonly) {
switch (item.type) {
case "text":
case "editor":
case "textarea":
return this.$_i18n(item.remark) || (this.checkDisable(item) ?
this.$_i18n(item.name) + this.$t("form.system_build") :
this.$t("form.write") + this.$_i18n(item.name));
break;
case "select":
case "dropdownchecklist":
return this.$t("form.select");
case "autocomplete":
case "autocomplete_remote":
return this.$t("form.autocomplete");
default:
return this.$_i18n(item.remark);
}
}else{
return "";
}
},setControlTitle(item) {
switch (item.type) {
case "text":
case "editor":
case "textarea":
return this.$_i18n(item.remark) || (this.checkDisable(item) ?
"" : this.$t("form.write") + this.$_i18n(item.name));
break;
default:
return this.$_i18n(item.remark) || (this.checkDisable(item) ?
"" : this.$t("form.select") + this.$_i18n(item.name));
break;
}
}, removeFile(item,file){
let data=this.form[item.code];
if(this.$d.isArray(data)){
let index= data.findIndex((d,index)=>{return d.uid==file.uid;})
if(data.length>index){
data.splice(index,1);
}
}else{
this.form[item.code]=[];
}
}, removeItem(item,index){
let data=this.form[item.code];
if(this.$d.isArray(data)){
if(data.length>index){
data.splice(index,1);
}
}else{
this.form[item.code]=[];
}
// item.linkageRule.hideAdd=false;
},perview(urlFormat,row){
if(urlFormat)
return urlFormat.urlFormat(row,false);
},handleFileChanged(file,fileList,item){
// if(this.form[item.code].length>=item.linkageRule.limit){
// item.linkageRule.hideAdd=true;
// }else{
// item.linkageRule.hideAdd=false;
// }
return true;
},clearable(item){
if(item.linkageRule&&item.linkageRule.clearable!=null)
return item.linkageRule.clearable;
else
return item.isEmpty||false;
}
}
}