'+
// 表格本身功能（标题、字段顺序、表刷新、表标签）
'
'+
// 功能组 - 新增、字段设置、共享文件夹
'
',
props: {
tableAttr: { // tableAttr.toolbarobj.isbasicfilterfields
type: Object,
default: function(){
return {
istitle: false,
title: "表格标题",
isborder: true, // 显示表格的网格线
isSelection: false, // 是否可多选
// 工具栏设置
toolbarobj: {
isfilterfield: true, // 是否显示高级筛选按键
isbasicfilterfields: true, // 是否显示基础筛选字段
// isdraggableorder: false, // 表格字段的拖拽设置
toolbuttons: [ // 常规按键设置
{name: "新增", code: "add", type: "primary", icon: "el-icon-plus", isselected: false, classname: ""},
{name: "详情", code: "browse", type: "primary", icon: "el-icon-tickets", isselected: true, classname: ""},
{name: "编辑", code: "edit", type: "primary", icon: "el-icon-edit", isselected: true, classname: ""},
{name: "删除", code: "del", type: "danger", icon: "el-icon-delete", isselected: true, classname: ""},
{name: "导出", code: "export", type: "primary", icon: "el-icon-download", isselected: false, classname: ""},
],
more_datalist: [ // 更多按键设置
// {name: "导出", code: "export", type: "primary", icon: "el-icon-download", isselected: false, classname: ""},
// {name: "提交", code: "submit", type: "success", icon: "el-icon-s-promotion", classname: ""},
// {name: "审批", code: "submit", type: "success", icon: "el-icon-s-promotion", classname: ""},
]
}
};
}
},
tool_button_filter: { // 筛选按键
type: Object,
default: function(){
return {
name: "高级搜索",
code: "filter",
type: "primary",
icon: "iconfont icon-guolv",
classname: "",
};
}
},
basicfilterAttr: { // 基础筛选属性
type: Object,
default: function(){
return {
istitle: false,
title: "表单名称",
columnnumber: 5,
labelwidth: "0px",
labelposition: "left",//"left",// right//top
size: "mini",
border: "1px solid #c6c6c600"
};
}
},
filterAttr: { // 筛选属性
type: Object,
default: function(){
return {
istitle: false,
title: "表单名称",
columnnumber: 4,
labelwidth: "100px",
labelposition: "left",//"left",// right//top
size: "mini",
border: "3px solid #c6c6c600"
};
}
},
basicfilterfields: { // 基础筛选字段
type: Array,
default: function(){
return [];
}
},
filterFields: { // 筛选字段
type: Array,
default: function(){
return [];
}
},
filtersobj: { // 筛选数据
type: Object,
default: function(){
return {
};
}
},
tableFormAttr: {
type: Object,
default: function(){
return {
columnnumber: 1,
labelwidth: "100px",
labelposition: "left",//"left",// right//top
size: "mini",
border: "0px solid #c6c6c600"
};
}
},
tableFieldClick: {//字段对应的点击事件
type: Object,
default: function(){
return {
};
}
},
tableButtonClick: {// 表格工具栏按键的点击事件(已作废)
type: Object,
default: function(){
return {
};
}
},
tableButtonsClick: {// 表格工具栏按键的点击事件
type: Array,
default: function(){
return [];
}
},
identificationfield: {//属性数据标识字段
type: String,
default: "field"
},
orderlabelfield: {//显示的字段
type: String,
default: "name"
},
orderisselect: {//显示和隐藏的字段及对应值
type: Object,
default: function(){
return {
field: "isshow",
show: "T",
hide: "F"
};
}
},
isshowtool: {//显示工具栏
type: Boolean,
default: true
},
istablebuttons: { //显示表格本身按键
type: Boolean,
default: true
},
tablebuttons: {//编辑界面行按键（编辑，删除）
type: Array,
default: function(){
return [
{name: "字段设置", code: "draggableorder", type: "default", icon: "el-icon-sort", classname: ""},
]
}
},
basicfilterfieldslength: { // 显示基础筛选字段的个数
type: Number,
default: 4
},
isbasicfilterfields: { // 是否显示基础筛选字段
type: Boolean,
default: true
},
isshowbasicfilterquery: { // 是否显示基础查询按键
type: Boolean,
default: true
},
isfilterfield: {// 是否显示高级筛选按键
type: Boolean,
default: true
},
isdraggableorder: {//字段顺序及显示按键
type: Boolean,
default: true
},
istree: {//树形列表的箭头单元格
type: Boolean,
default: false
},
defaultExpandAll: {//是否默认全展开
type: Boolean,
default: false
},
////对比
isOldContrast: {//是否对比差异isOldContrast//tableDataOld
type: Boolean,
default: false
},
isAddContrast: {//是否显示新增差异isOldContrast//tableDataOld//isAddContrast
type: Boolean,
default: false
},
tableDataOld: {//对比差异的历史数据
type: Object,
default: function(){
return {};
}
},
treeprops: {//树形数据配置
type: Object,
default: function(){
return {children: 'children', hasChildren: 'haschildren'};
}
},
lazy: {//tableAttr
type: Boolean,
default: false
},
"layout": {//无数据的图片
type: String,
default: "total, sizes, prev, pager, next"//"total, sizes, prev, pager, next, jumper"
},
"tableFields": Array,//字段
"tableData": Array,//数据
"selectTableData": {//选中的数据
type: Array,
default: function(){
return [];
}
},
"tableloading": {//tableAttr
type: Boolean,
default: false
},
stripe: {//斑马条纹
type: Boolean,
default: true
},
"tablelanguage": {//表格语言
type: String,
default: "zh"
},
"url_img2": {//无数据的图片
type: String,
default: window.top.config.url_page + "img/zanwushuju.png"
},
"href": {//无数据的图片
type: String,
default: "table1"
},
"rowkey": {//树形数据时需要设置
type: String,
default: null
},
"showSummary": {//是否在表尾显示合计行tableAttr
type: Boolean,
default: false
},
isshowShoppingcart: {//是否在多选时显示共享文件夹
type: Boolean,
default: true
},
shoppingcartRewriteFields: { // 在购物车中的数据要回写到重新查询数据中的字段
type: Array,
default: function(){
return [];
}
},
selectedIdByFields: {//已选择的行数据（唯一标识字段，可以是多字段的组合）
type: Array,
default: function(){
return ["id"];
}
},
// initSelectedList: {//已选择的行数据数组（初始已选数据）
// type: Array,
// default: function(){
// return [
// {id:"123"}
// ];
// }
// },
"isSelection": {//多选tableAttr
type: Boolean,
default: false
},
"isShowIndex": {//序号tableAttr
type: Boolean,
default: false
},
"isWithinEditTableData": {//表内编辑
type: Boolean,
default: false
},
"isEditTableData": {//编辑/删除按键
type: Boolean,
default: false
},
"isHighlightRow": {//选中高亮tableAttr
type: Boolean,
default: false
},
"isPagination": {//是否显示分页
type: Boolean,
default: true
},
"editTableButton": {//编辑界面行按键（编辑，删除）
type: Object,
default: function(){
return {
edit: {
isshow:true,
txt:"编辑"
},
del: {
isshow:true,
txt:"删除"
},
save: {
isshow:true,
txt:"保存"
},
}
}
},
"expands": Array,//展开的节点
emptytext: {//空数据显示内容
type: String,
default: "无数据"
},
tableHeight: {
type: Number,
default: null
},
pagesize: {
type: Number,
default: 10
},
pagenum: {
type: Number,
default: 1
},
total: {
type: Number,
default: 0
},
},
data() {
return {
// tablebuttons: [ // 表格本身功能按键
// {name: "字段设置", code: "draggableorder", type: "default", icon: "el-icon-sort", classname: ""},
// ],
dialogDraggableorder: false,
isdraggableorder_switchfloat: "right",
filterFieldClick: {},//筛选字段对应的点击事件
system_config: system_config,
page_title: system_config.whole_config.theme_config.page_title,
isdraggablegroup: false,
filterpopoverwidth: 400,
zpagesize: this.pagesize,
zpagenum: this.pagenum,
istableloading: true,
istablehover: false,
summaries: [],
z_old_tableData: [],
tableToolButtons: [],
tableToolButtonClicks: {},
tablefiltersobj: this.filtersobj,
tableFields_obj: {},
tableFilterFields: [],
tableBasicFilterFields: [],
basicFilterButton: {
query: false,//查询
empty: false,//重置
add: false,//添加
import: false,//导入
export: false,//导出
},
popover_tablefilter: false,
selection_cnt: 0,
show_maxcnt: 99,
popover_shoppingcart: false,
selectRowIndex: -1, // 单行选中时将单行数据放到这个数组中，目的为了和多选的事件能统一
selectRowList: [], // 单行选中时将单行数据放到这个数组中，目的为了和多选的事件能统一
selectedList: clone(this.selectTableData),
selectedMap: {},//已选择的行数据对象（初始已选数据根据唯一字段转换的对象）
doTableFieldObjs: {},
tablelanguage_map: {
zh: {
totalcnt: "总共",
selected: "已选择",
row: "条",
clear: "清空选择",
operation: "操作",
no_: "序号",
empty: "无数据",
query: "查询",
},
en: {
totalcnt: "Total",
selected: "Selected",
row: "Row",
clear: "Clear",
operation: "operation",
no_: "No.",
empty: "empty",
query: "Query"
}
},
doFieldsObj: {},
showTableFields: [],
selectHandle: function(row, rowIndex) {//多选时的复选框禁止选择事件
if (row.h_classname == "z_notrowclick" || row.h_notrowclick) {
return false
}
else {
return true
}
},
}
},
created() {
// var tableFields_ = clone(this.tableFields);
// if (tableFields_ && tableFields_.length) {
// var tableFields_2 = listTOTableFieldsGroup(tableFields_, "tablegroupname", "name");
// this.tableFields = clone(tableFields_2);
// }
},
mounted() {
var me = this;
// 表格工具栏常规按键的显示，如果页面有对应事件才显示此按键
// if (this.tableAttr && this.tableAttr.toolbarobj && this.tableAttr.toolbarobj.toolbuttons) {
// var tableToolButtons_ = [];
// this.tableAttr.toolbarobj.toolbuttons.map(b=>{
// if (this.tableButtonClick[b.code] && this.tableButtonClick[b.code].onclick) {
// tableToolButtons_.push(b);
// }
// })
// this.tableToolButtons = clone(tableToolButtons_);
// var tableToolButtonClicks_ = {}
// for (var buttoncode in this.tableButtonClick) {
// var b_ = this.tableButtonClick[buttoncode];
// tableToolButtonClicks_[buttoncode] = clone(b_);
// tableToolButtonClicks_[buttoncode].code = buttoncode;
// //name 如果翻译库中有有翻译库的
// if (buttonsconfig[buttoncode]) {
// tableToolButtonClicks_[buttoncode].name = buttonsconfig[buttoncode].name;
// if (!tableToolButtonClicks_[buttoncode].icon) {
// tableToolButtonClicks_[buttoncode].icon = buttonsconfig[buttoncode].icon;
// }
// }
// }
// this.tableToolButtonClicks = tableToolButtonClicks_;
if (this.tableButtonsClick.map) {
var tableToolButtons_ = []
this.tableButtonsClick.map(b=>{
var b_ = clone(b);
if (buttonsconfig[b.code]) {
b_.name = buttonsconfig[b.code].name;
if (!b_.icon) {
b_.icon = buttonsconfig[b.code].icon;
}
}
if (b_.isbuttonshow) {
tableToolButtons_.push(b_);
}
})
this.tableToolButtons = clone(tableToolButtons_);
}
// }
this.filterFieldClick = clone(this.tableFieldClick);
this.tablelanguage_map.zh.empty = this.emptytext;
this.istableloading = true;
this.setNotTableData();
if (this.selectedList.length) {
//初始已选数据根据唯一字段转换的对象
this.selectedList.map(r=>{
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += r[id_field];
})
this.selectedMap[e_id_val] = r;
})
}
if (this.selectTableData && this.selectTableData.length) {
this.toggleSelection(clone(this.selectTableData));
}
},
computed: {
isShowTable() {
var me = this;
var is_filterFields = false;
var tableFilterFields_ = [];
// 设置高级筛选字段
if (this.filterFields && this.filterFields.length) {
is_filterFields = true;
this.tableFilterFields = clone(this.filterFields)
}
else {
this.tableFilterFields = []
}
this.tableFields.map(e=>{
if (!is_filterFields) {
var f = clone(e);
f.isshow = "T";
if (f.isfilter) { // 是基础过滤字段
f.isopenshow = true;
tableFilterFields_.push(clone(f));
}
else if (!f.isnotfilter) { // 不是不显示的过滤字段, 缺少是否基础字段的判断在规定查询个数内
var filter_f = clone(f);
// filter_f.isshow = "F";
tableFilterFields_.push(filter_f);
}
}
me.tableFields_obj[e.field] = e;
//国际化设置，目前仅支持中/英
if (h_language && h_language=="en" && e.labelenglish) {
if (!e.labelchinese) {
e.labelchinese = clone(e.name);
}
e.name = clone(e.labelenglish);
}
else {
if (e.labelchinese) {
e.name = clone(e.labelchinese);
}
}
});
if (!is_filterFields) {
this.tableFilterFields = clone(tableFilterFields_);
}
if (this.$refs.ref_notTableData) {
this.setNotTableData();
}
return (this.tableData && this.tableData.length > 0) ? true : true; //false;
},
doTableFields() {
var me = this;
this.istableloading = true;
me.showTableFields = [];
var me_tableFields = clone(this.tableFields);
if (me_tableFields.length > 0 ) {
// 表格字段设置配置
me_tableFields.map(t=>{
if (t.isshow == "T") {
me.showTableFields.push(t);
}
})
// 表格字段分组，根据tableformgroup判断tablegroupname是否表格单元格中的表单分组
me_tableFields = listTOTableFieldsGroupByType(me_tableFields);
}
me_tableFields.map(t=>{
if (t.inputtype && !t.type) {
t.type = t.inputtype.toLowerCase();
}
// 设置胶囊样式
// if (t.type == 'tag' || t.type == 'capsuletag') {
// //从字典获取对应样式
// var tagtypeList_ = window.top.Dictionary.getList("tagtype");
// var tagtype_ = {};
// tagtypeList_.map(tt=>{
// tagtype_[tt.code] = tt.value;
// })
// t.tagtype = tagtype_;
// }
// if (t.tagtype && typeof t.tagtype === 'string') {
// var tagtype = t.tagtype.replace(/\^/g, '\"');
// t.tagtype = JSON.parse(tagtype);
// }
me.tableFieldAttr(t);
})
var oldTableFields_ = clone(me_tableFields);
// if (me_tableFields.length > 0 ) {
// // 表格头分组
// oldTableFields_ = listTOTableFieldsGroup(me_tableFields, "tablegroupname", "name");
// }
if (me_tableFields.length > 0 ) {
// 表格单元格中的表单分组
oldTableFields_= listTOtableGroup(me_tableFields, "table_formgroup_name", "formchildren");
}
var tableFields_2 = listTOTableFieldsGroup(oldTableFields_, "tablegroupname", "name");
var tableFields_ = clone(tableFields_2);
var rowindex = 0;
var index = 0;
var doFieldsObj_ = {};
if(this.isEditTableData) {
index = 0;
}
me.setFieldsObj(tableFields_,rowindex, index, doFieldsObj_, function(fieldsObj) {
me.doFieldsObj = clone(fieldsObj);
});
// return this.tableFields;
return tableFields_;
}
},
watch: {
tableButtonsClick() {
if (this.tableButtonsClick.map) {
var tableToolButtons_ = []
this.tableButtonsClick.map(b=>{
var b_ = clone(b);
if (buttonsconfig[b.code]) {
b_.name = buttonsconfig[b.code].name;
if (!b_.icon) {
b_.icon = buttonsconfig[b.code].icon;
}
}
if (b_.isbuttonshow) {
tableToolButtons_.push(b_);
}
})
this.tableToolButtons = clone(tableToolButtons_);
}
},
isEditTableData() {
var me = this;
var ref = this.href;
this.$nextTick(function() {
me.$refs[ref].doLayout();
me.istableloading = false;
})
},
// selectTableData(newVal, oldVal){
// if (this.selectTableData && this.selectTableData.length) {
// this.toggleSelection(clone(this.selectTableData));
// }
// else {
// this.toggleSelection();
// }
// },
tableData() {
// if (!(this.tableAttr.isSelection || this.isSelection)) { // 如果不是多选则清空
this.selectRowList = [];
this.selectRowIndex = -1;
// }
this.$nextTick(function() {
this.tableData.map(r=>{
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += r[id_field];
})
if (this.selectedMap[e_id_val]) {
var s_r = this.selectedMap[e_id_val]
// 存在需要回写的字段，在购物车中的数据要回写到重新查询数据中的字段
if (this.shoppingcartRewriteFields && this.shoppingcartRewriteFields.length) {
this.shoppingcartRewriteFields.map(srf=>{
if (!r[srf] && s_r[srf]) {
this.$set(r, srf, s_r[srf])
}
})
// 同步共享文件夹中的该条数据
this.selectedList.remove(this.selectedMap[e_id_val]);
this.selectedList.unshift(r);
}
var ref = this.href;
this.$refs[ref].toggleRowSelection(r, true)
}
})
})
},
selectedList() {
this.selectedMap = {};
if (this.selectedList.length) {
//初始已选数据根据唯一字段转换的对象
this.selectedList.map(r=>{
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += r[id_field];
})
this.selectedMap[e_id_val] = r;
})
}
},
tableFilterFields() {
// 设置基础筛选字段
var tableBasicFilterFields_ = [];
var tableBasicFilterFields_me = [];
this.tableBasicFilterFields = [];
if (this.basicfilterfields && this.basicfilterfields.length) {
tableBasicFilterFields_me = clone(this.basicfilterfields)
}
else {
var tableFilterFields__ = clone(this.tableFilterFields);
tableFilterFields__.filter(f=>{
if (f.isopenshow && tableBasicFilterFields_.length < this.basicfilterfieldslength) {
tableBasicFilterFields_.push(clone(f));
}
})
tableBasicFilterFields_me = clone(tableBasicFilterFields_)
}
this.tableBasicFilterFields = clone(tableBasicFilterFields_me);
},
filtersobj() {
this.tablefiltersobj = this.filtersobj
}
},
methods: {
moreclick(buttonobj) {
if (buttonobj.code == "draggableorder") {
this.dialogDraggableorder = true;
}
},
toolbuttonclick(buttonobj) {
let obj = {
buttonobj: buttonobj // 按键属性
}
obj.selectRowIndex = -1;
// 表格的选中项
// if (this.tableAttr.isSelection || this.isSelection) { // 如果是多选
if (buttonobj.islistselected) { // 如果是多选
obj.selectedList = this.selectedList
}
else {
obj.selectRowIndex = this.selectRowIndex;
obj.selectedList = this.selectRowList;
}
// table-button-click
if (buttonobj.onclick) {
buttonobj.onclick(obj);
}
else if (this.tableButtonClick[buttonobj.code] && this.tableButtonClick[buttonobj.code].onclick) {
this.tableButtonClick[buttonobj.code].onclick(obj);
}
},
onShowFilterPopover() {
this.filterpopoverwidth = this.$refs['h_tabletool' + this.href].offsetWidth - 34;
},
h_onChange(obj) {
if (this.isshowbasicfilterquery) {
return
}
let page = {
pagesize: this.zpagesize,
pagenum: 1,
filtersobj: obj.data
}
this.$emit('get-data', page);
},
h_onQuery() {
let page = {
pagesize: this.zpagesize,
pagenum: 1,
filtersobj: this.tablefiltersobj
}
this.$emit('get-data', page);
this.popover_tablefilter = false;
},
h_onInitQuery() {
this.tablefiltersobj = {};
let page = {
pagesize: this.zpagesize,
pagenum: 1,
filtersobj: this.tablefiltersobj
}
this.$emit('get-data', page);
this.popover_tablefilter = false;
},
//共享文件夹事件
shoppingcartDataRow(code, scope) {
var row = scope.row;
if (code == "delete") { // 从共享文件夹中移出
if (row.h_notrowclick) { // 如果是选中锁定的行不能移出
this.$message({
type: 'warning',
message: '选中锁定的行不能移出'
});
return
}
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += row[id_field];
})
// 如果共享文件夹中有，则从共享文件夹中删除
if (this.selectedMap[e_id_val]) {
this.selectedList.remove(this.selectedMap[e_id_val]);
delete this.selectedMap[e_id_val];
}
// 取消当前表格中的对应数据的选中状态
this.tableData.map(r=>{
var e2_id_val = "";
this.selectedIdByFields.map(id_field=>{
e2_id_val += r[id_field];
})
if (e2_id_val == e_id_val) {
var ref = this.href;
this.$refs[ref].toggleRowSelection(r, false)
}
})
// this.$emit('shoppingcart-del-data', scope);
}
},
getShoppingcart() {
return this.selectedList;
},
//清空共享文件夹
emptyShoppingcart() {
// 取消当前表格中的对应数据的选中状态
this.tableData.map(r=>{
var e2_id_val = "";
this.selectedIdByFields.map(id_field=>{
e2_id_val += r[id_field];
})
if (this.selectedMap[e2_id_val]) {//如果在共享文件夹中则取消选中
var ref = this.href;
this.$refs[ref].toggleRowSelection(r, false)
}
})
//清空共享文件夹
this.selectedList = [];
this.popover_shoppingcart = false;
},
saveShoppingcart(list) {
this.popover_shoppingcart = false;
this.$emit('save-shoppingcart', list);
},
table_hover(ishover) {
if (ishover) {
this.istablehover = true;
}
else {
this.istablehover = false;
}
},
saveOrder(v) {
this.$emit('order-fields', v);
},
isArray(r){
return Object.prototype.toString.call(r)== '[object Array]';
},
setFieldsObj(list, rowindex, index, doFieldsObj_, callback) {
list.map(l=>{
if(l.isshow == "T"){
if (!doFieldsObj_[rowindex]) {
doFieldsObj_[rowindex] = {};
}
else {
index++;
}
doFieldsObj_[rowindex][index] = l;
if (l.children) {
var rowindex_ = rowindex + 1;
var index_ = 0;
if(doFieldsObj_[rowindex_]){
index_ = Object.keys(doFieldsObj_[rowindex_]).length - 1;
}
this.doSetFieldsObj(l.children, rowindex_, index_, doFieldsObj_);
}
}
})
callback(doFieldsObj_);
},
doSetFieldsObj(list, rowindex, index, doFieldsObj_) {
list.map(l=>{
if (!doFieldsObj_[rowindex]) {
doFieldsObj_[rowindex] = {};
}
else {
index++;
}
doFieldsObj_[rowindex][index] = l;
if (l.children) {
var rowindex_ = rowindex + 1;
var index_ = 0;
this.doSetFieldsObj(l.children, rowindex_, index_, doFieldsObj_);
}
})
},
tableFieldAttr(t) {
var me = this;
if (t.children) {
this.tableFieldAttr(t.children);
}
else {
if(this.isArray(t)) {
t.map(e=>{
me.tableFieldAttr(e);
})
}
else {
this.doTableFieldAttr(t);
}
}
},
doTableFieldAttr(e) {
//国际化设置，目前仅支持中/英
if (h_language && h_language=="en" && e.labelenglish) {
if (!e.labelchinese) {
e.labelchinese = clone(e.name);
}
e.name = clone(e.labelenglish);
}
else {
if (e.labelchinese) {
e.name = clone(e.labelchinese);
}
}
//设置下拉选项的（根据字典数据设置）
if (e.type == "select" || e.type == "selectmultiple" || e.type == "cascader") {
if (!e.props) {
var props_ = {value: "code", label: "value"};
e.props = clone(props_);
}
if (e.optionsgroup) {
//:options="fieldObj.options" :props="fieldObj.props"
//根据optionsname获取公用的对应关系，从字典中获取,字典数据从数据库获取
var list_ = window.top.Dictionary.getList(e.optionsgroup);
e.options = clone(list_);
}
else if(!e.options) {
e.options = []
}
}
if (e.type == "radio" || e.type == "checkboxobj") {
if (e.optionsgroup) {
//:options="fieldObj.options" :props="fieldObj.props" ;//{value: "code", label: "value"};
//根据optionsname获取公用的对应关系，从字典中获取,字典数据从数据库获取
var list_ = window.top.Dictionary.getList(e.optionsgroup);
e.options = clone(list_);
}
else if(!e.options) {
e.options = []
}
}
if (e.formatter) {
//formatpattern 格式设置（可以是小数位数。也可以是时间、日期的格式）
if (e.formatter == "formatter_json") {
var json_ = {};
if (e.formatterjson) {
//说明是对应关系
json_ = e.formatterjson;
}
else if (e.formatpattern){
//根据formatpattern获取公用的对应关系，从字典中获取,字典数据从数据库获取
var map_ = window.top.Dictionary.getMap(e.formatpattern);
json_ = e.formatterjson = clone(map_);
}
else if (!e.formatpattern && e.optionsgroup){
//根据optionsgroup下拉组名获取公用的对应关系，从字典中获取,字典数据从数据库获取
var map_ = window.top.Dictionary.getMap(e.optionsgroup);
json_ = e.formatterjson = clone(map_);
}
e.formatter_f = function(a,b,c,d) {return formatter_json(a,b,c,d, json_)}
}
else if (e.formatter == "formatter_money") {
var digit = e.formatpattern;//小数位数，默认2位
e.formatter_f = function(a,b,c,d) {return formatter_money(a,b,c,d, digit)}
}
else if(e.formatter == "formatter_date") {
var format = e.formatpattern;//日期格式，默认"yyyy-MM-dd"
e.formatter_f = function(a,b,c,d) {return formatter_date(a,b,c,d, format)}
}
else if(e.formatter == "formatter_float") {
var digit = e.formatpattern;//小数位数，默认2位
e.formatter_f = function(a,b,c,d) {return formatter_float(a,b,c,d, digit)}
}
else if(e.formatter == "formatter_percent") {
var digit = e.formatpattern;//小数位数，默认2位
e.formatter_f = function(a,b,c,d) {return formatter_percent(a,b,c,d, digit)}
}
else if(e.formatter == "formatter_prefixorunit") {
var prefix = e.prefix;//前缀
var unit = e.suffix;//后缀或单位
e.formatter_f = function(a,b,c,d) {return formatter_prefixorunit(a,b,c,d, prefix, unit)}
}
else if(e.formatter == "formatter_split") {
var format = e.formatpattern;//拼接的字段格式 format = "#{name}-{name}%"
e.formatter_f = function(a,b,c,d) {return formatter_split(a,b,c,d, format)}
}
else if(e.formatter == "formatter_password") {
e.formatter_f = function(a,b,c,d) {return formatter_password(a,b,c,d)}
}
else if(e.formatter == "formatter_earlyWarning") {
e.formatter_f = function(a,b,c,d) {return formatter_earlyWarning(a,b,c,d)}
}
}
/* else if(e.field != "id") {
e.formatter_f = function(row, column, cellValue, index) {
if (typeof cellValue === 'number' && !isNaN(cellValue)) {//主要针对int 0
return cellValue.toString();
}
else return cellValue
}
} */
if (e.field) {
this.doTableFieldObjs[e.field] = e;
}
return e;
},
tableRowClassName({row, rowIndex}) {
if (row.h_classname) {
return row.h_classname;
}
return '';
},
cellClass(obj) {
// if(clone(this.tableData) == clone(this.z_old_tableData)) {
// return
// }
// this.z_old_tableData = clone(this.tableData);
obj.row.h_rowindex = obj.rowIndex;
let field = obj.column.property;
let row_ = [];
var row_field = this.doTableFieldObjs[field];
if (row_field) {
row_.push(row_field);
}
/* let row_ = this.doTableFields.filter(item => {
return item.field == field;
}); */
let class_ = "";
//业务上的样式，如：可点击，存在上下限等
if(this.tableFieldClick[field] && this.tableFieldClick[field].val && this.tableFieldClick[field].val.onclick) {
class_ = "h_cellclick";
}
if(row_.length > 0 && (row_[0].maxval || row_[0].minval)) {
if (row_[0].formatter == "formatter_earlyWarning") {
if (row_[0].earlyWarningField) {
var field1 = row_[0].earlyWarningField[0];
var field2 = row_[0].earlyWarningField[1];
var d_ = 0;
var date_field1 = null;
var date_field2 = null;
if (field1 == "znewdate") {
date_field1 = Date.parse(new Date());
}
else if(obj.row[field1]) {
date_field1 = Date.parse(new Date(obj.row[field1]));
}
if (field2 == "znewdate") {
date_field2 = Date.parse(new Date());
}
else if(obj.row[field2]) {
date_field2 = Date.parse(new Date(obj.row[field2]));
}
var d_ = parseInt((date_field1-date_field2)/ (1000 * 60 * 60 * 24));
obj.row[field] = d_;
}
//-----警告---minval----预警------maxval-----正常--
if (obj.row[field] * 1 > row_[0].maxval * 1) {
//正常
class_ += " h_notoverflowval";
}
else if(obj.row[field] * 1 < row_[0].minval * 1) {
//警告
class_ += " h_overflowval";
}
else {
//预警
class_ += " h_earlywarning";
}
}
else if((row_[0].maxval && obj.row[field] * 1 > row_[0].maxval * 1) || (row_[0].minval && obj.row[field] * 1 < row_[0].minval * 1)) {
class_ += " h_overflowval";
}
else class_ += " h_notoverflowval";
}
if(row_.length > 0 && row_[0].formatter == "formatter_TF2") {
if(obj.row[field] == "T" || obj.row[field] == "S1"
|| obj.row[field] == "S2" || obj.row[field] == "S3") {
class_ += " h_stamp";
}
}
if(row_.length > 0 && row_[0].isstamp) {
if(obj.row[field]) {
class_ += " h_stamp";
}
}
if(this.tableFieldClick[field] && this.tableFieldClick[field].val && this.tableFieldClick[field].val.onclick) {
var notclick_vals = this.tableFieldClick[field].val.notclick_val;
var notclick_bindfields = this.tableFieldClick[field].val.notclick_bindfield;
// if (row_.length > 0 && row_[0].iscellclick && !row_[0].isclick) {
if((!obj.row[field] || obj.row[field] == "") && obj.row[field] != 0 && (!this.tableFieldClick[field].defaultval || (this.tableFieldClick[field].defaultval && !this.tableFieldClick[field].defaultval.onclick))) {
class_ += " h_notclick";
}
if (notclick_vals) {
var notclick_vals_ = [];
if (typeof(notclick_vals) == "string") {
notclick_vals_ = notclick_vals.split(";");
}
else if (Array.isArray(notclick_vals)) {
notclick_vals_ = notclick_vals;
}
var bo_ = false;
var val_ = obj.row[field];
notclick_vals_.map(v=>{
if (val_ == v) {
bo_ = true;
}
});
if (bo_) {
class_ += " h_notclick";
}
}
//notclick_bindfield: [{field: "folw_id", val: null},{}]
if (notclick_bindfields && notclick_bindfields.length) {
var bo_ = false;
notclick_bindfields.map(b=>{
var val_ = obj.row[b.field];
if (val_ == b.val) {
bo_ = true;
}
});
if (bo_) {
class_ += " h_notclick";
}
}
}
//如果存在自定义的class
if(row_.length > 0 && row_[0].cssname) {
class_ += " " + row_[0].cssname;
}
if(this.tableFieldClick[field] && this.tableFieldClick[field].cssname) {
this.tableFieldClick[field].cssname(obj.row, function(classname){
if (classname) {
class_ += " " + classname;
}
})
}
//如果存在差异则背景高亮isOldContrast//tableDataOld
if(this.isOldContrast && !(this.isWithinEditTableData || obj.row.isWithinEdit)) {
var row_n = obj.row;
if (this.tableDataOld[row_n.id] && row_n.id) {//如果存在历史数据
var row_o = this.tableDataOld[row_n.id];
if (row_n[field] != row_o[field] && (row_n[field] || row_o[field])) {
var f_o = null;
var f_n = null;
if (row_n[field]) {
f_n = JSON.stringify(row_n[field]);
}
if (row_o[field]) {
f_o = JSON.stringify(row_o[field]);
}
if(f_n != f_o) {
class_ += "z_contrast_tablecall";
}
}
}
else if (this.isAddContrast && !this.tableDataOld[row_n.id] && row_n.id) { // 显示新增数据差异
this.tableDataOld[row_n.id] = {};
class_ += "z_contrast_tablecall";
}
}
return class_;
},
setNotTableData() {
var me = this;
if (!this.tableData || (this.tableData && this.tableData.length == 0) ) {
// this.$refs.ref_notTableData.style['height'] = this.tableHeight + "px";
//this.$refs.ref_notTableData.style['min-height'] = this.tableHeight + "px";
//this.$refs.ref_notTableData.style['padding-top'] = (this.tableHeight * 0.3)+"px";
this.$refs.ref_notTableData.style['width'] = "100%";
}
else {
//设置默认值
this.tableData.map(d=>{
me.tableFields.map(f=>{
me.notTableData(d, f);
})
});
this.$refs.ref_notTableData.style['height'] = "0px";
this.$refs.ref_notTableData.style['min-height'] = "0px";
this.$refs.ref_notTableData.style['padding-top'] = "0px";
this.$refs.ref_notTableData.style['width'] = "0px";
}
var ref = this.href;
this.$nextTick(function() {
//me.$refs[ref].doLayout();
setTimeout(() => {
if (me.$refs[ref]) {
me.$refs[ref].doLayout();
}
me.istableloading = false;
}, 100);
})
},
notTableData(d, f) {
var me = this;
if (f.children) {
this.notTableData(d, f.children);
}
else {
if(this.isArray(f)) {
f.map(e=>{
me.notTableData(d, e);
})
}
else {
this.doNotTableData(d, f);
}
}
},
doNotTableData(d, f) {
//isassignment: 是否默认值替换原值 ，如果有保存会被替换
if (!d[f.field] && f.defaultval && f.isassignment) {
//defaultval_filter： 默认值的条件第一层数组的元素是or, 里面的数组元素是and
//type: 是条件，如果没有则是等于val值时可替换， "isnull"为空时，"isnotnull" 不为空时
if (f.defaultval_filter) {//:[[{field: "", val: ""},{field: "", val: ""}], [{}]]
var defaultval_filter_ = f.defaultval_filter;
if (f.defaultval_filter instanceof String) {
defaultval_filter_ = JSON.parse(f.defaultval_filter);
}
defaultval_filter_.map(m=>{
var bo_m = true;
m.map(mf=>{
if (!mf.type) {
if (d[mf.field] != mf.val) {
bo_m = false
}
}
else if (mf.type == "isnull") {
if (d[mf.field]) {
bo_m = false
}
}
else if (mf.type == "isnotnull") {
if (!d[mf.field]) {
bo_m = false
}
}
});
if (bo_m) {
d[f.field] = f.defaultval
}
else {
//单条设置不显示默认值的字段
if (!d.z_h_notdefaultval) {
d.z_h_notdefaultval = {};
}
d.z_h_notdefaultval[f.field] = true;
}
})
}
else {
d[f.field] = f.defaultval
}
}
//return d;
},
setCurrentRow(row) {
this.$refs.table1.setCurrentRow(row);
if (row) {
this.selectRowList = [row] // 单行选中时将单行数据放到这个数组中，目的为了和多选的事件能统一
}
},
sortChange({column, prop, order}) {
if (this.tableFields_obj[prop] && this.tableFields_obj[prop].issortable && this.tableFields_obj[prop].issortable == true) {
return
}
let obj = {
column: column,
prop: prop,
order: order,
field: this.tableFields_obj[prop]
}
this.$emit('orderby-change', obj);
},
arraySpanMethod({ row, column, rowIndex, columnIndex }) {
let obj = {
row: row,
column: column,
rowIndex: rowIndex,
columnIndex: columnIndex
}
var result = [];
if (this.$listeners["span-method"]) {
this.$emit('span-method', obj, function(r) {
result = r;
});
}
else {
return [1,1];
}
return result;
//（返回数组）return [1,2] 1行2列。columnIndex 是行号
//（返回对象）return {rowspan: 2, colspan: 1} 2行1列。columnIndex 是行号
},
checkClick(data, checked, indeterminate) {
let obj = {
data: data,
checked: checked,
indeterminate: indeterminate
}
this.$emit('check-click', obj);
},
load(tree, treeNode, resolve) {
/* let obj = {
data: data,
checked: checked,
indeterminate: indeterminate
} */
this.$emit('load-click', tree, treeNode, resolve);
},
rowClick(row, column, event) {
var is_click = true;
let field = ""
if (column) {
field = column.property;
}
// 设置禁止点击class的
if (event.currentTarget.classList) {
event.currentTarget.classList.forEach((class_, index)=>{
if (class_ == "z_notrowclick") {
is_click = false;
return
}
})
}
// 设置单元格点击的单元格点击时
if (this.tableFieldClick[field] && this.tableFieldClick[field].cell && this.tableFieldClick[field].cell.onclick) {
is_click = false;
}
// 设置选中锁定的
if (row.h_notrowclick) {
is_click = false;
}
if (!is_click) {
return
}
let obj = {
column: column,
event: event
}
var ref = this.href;
var selectRow = clone(row);
delete selectRow.h_rowindex;
// 选中行再次点击要取消选中
if (this.selectRowList.length && JSON.stringify(this.selectRowList[0]) == JSON.stringify(selectRow)) {
this.$refs[ref].setCurrentRow(); // 取消行选中高亮
this.selectRowList = []; // 清空表格工具栏上的选择行信息
this.selectRowIndex = -1;
obj.row = {}; // 清空页面上的选择行信息
if (this.tableAttr.isSelection || this.isSelection) { // 如果是多选，取消该行的选中和共享文件夹中的数据
this.$refs[ref].toggleRowSelection(row, false);
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += row[id_field];
})
// 如果共享文件夹中有，则从共享文件夹中删除
if (this.selectedMap[e_id_val]) {
this.selectedList.remove(this.selectedMap[e_id_val]);
delete this.selectedMap[e_id_val];
}
}
else { // 单选
this.selectedList = []
}
}
else { // 不是选中行的会被选中，如果没有勾选则勾选
var selectedList_ = [];
selectedList_.push(selectRow);
this.selectRowList = clone(selectedList_);
this.selectRowIndex = clone(row.h_rowindex);
obj.row = row;
if (this.tableAttr.isSelection || this.isSelection) { // 如果是多选，则复选框也选中
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += row[id_field];
})
// 如果共享文件夹中没有, 则勾选
if (!this.selectedMap[e_id_val]) {
this.$refs[ref].toggleRowSelection(row, true);
}
}
else { // 单选
this.selectedList = this.selectRowList
}
}
this.$emit('row-click', obj);
},
//外部调用选中行事件
selectedRow(row, isselect) {
// isselect 是否需要选中
let obj = {}
var ref = this.href;
var selectRow = clone(row);
delete selectRow.h_rowindex;
// 已经选中行
if (this.selectRowList.length && JSON.stringify(this.selectRowList[0]) == JSON.stringify(selectRow)) {
// 如果isselect=true,则需要选中，已经被选中的不需要动作。如果isselect=false,则需要不选中，已经被选中的则要取消选中。
if (isselect) {
return
}
this.$refs[ref].setCurrentRow(); // 取消行选中高亮
this.selectRowList = []; // 清空表格工具栏上的选择行信息
this.selectRowIndex = -1;
obj.row = {}; // 清空页面上的选择行信息
if (this.tableAttr.isSelection || this.isSelection) { // 如果是多选，取消该行的选中和共享文件夹中的数据
this.$refs[ref].toggleRowSelection(row, false);
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += row[id_field];
})
// 如果共享文件夹中有，则从共享文件夹中删除
if (this.selectedMap[e_id_val]) {
this.selectedList.remove(this.selectedMap[e_id_val]);
delete this.selectedMap[e_id_val];
}
}
else { // 单选
this.selectedList = []
}
}
else { // 不是选中行 //的会被选中，如果没有勾选则勾选
// 如果isselect=true,则需要选中，没选中的则要选中。如果isselect=false,则需要不选中，没选中的不需要动作。
if (!isselect) {
return
}
var selectedList_ = [];
selectedList_.push(selectRow);
this.selectRowList = clone(selectedList_);
this.selectRowIndex = clone(row.h_rowindex);
obj.row = row;
if (this.tableAttr.isSelection || this.isSelection) { // 如果是多选，则复选框也选中
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += row[id_field];
})
// 如果共享文件夹中没有, 则勾选
if (!this.selectedMap[e_id_val]) {
this.$refs[ref].toggleRowSelection(row, true);
}
}
else { // 单选
this.selectedList = this.selectRowList
}
}
// this.$emit('row-click', obj);
},
headerCellStyle(obj) {
var aa = obj;
var rowIndex = obj.rowIndex;
var index = obj.columnIndex;
var style_ = {
/* 'background':'#FAFAFA',
'color':'black', */
'text-align':'center'
}
let field = obj.column.property;
let label = obj.column.label;
let row_ = {};
if (field == "phone") {
var aa = "";
}
if (field) {
/* let row_field = this.doTableFields.filter(item => {
return item.field == field;
}); */
row_ = this.doTableFieldObjs[field];
}
else {
row_ = this.doFieldsObj[rowIndex][index];
}
if (row_ && row_.headercolor) {
//if (row_.length && row_[0].headercolor) {
style_.background = row_.headercolor;
}
return style_;
},
rowDblclick(row, column, event) {
var is_click = true;
let field = column.property;
// 设置禁止点击class的
if (event.currentTarget.classList) {
event.currentTarget.classList.forEach((class_, index)=>{
if (class_ == "z_notrowclick") {
is_click = false;
return
}
})
}
// 设置单元格点击的单元格点击时
if (this.tableFieldClick[field] && this.tableFieldClick[field].cell && this.tableFieldClick[field].cell.onclick) {
is_click = false;
}
// 设置选中锁定的
if (row.h_notrowclick) {
is_click = false;
}
if (!is_click) {
return
}
let obj = {
row: row,
column: column,
event: event
}
this.$emit('row-dblclick', obj);
},
cellClick(row, column, cell, event) {
var is_click = true;
let field = column.property;
if (event.currentTarget.classList) {
event.currentTarget.classList.forEach((class_, index)=>{
if (class_ == "z_notrowclick") {
is_click = false;
return
}
})
}
if (!is_click) {
return
}
let obj = {
row: row,
column: column,
cell: cell,
event: event
}
if (this.tableFieldClick[field] && this.tableFieldClick[field].cell && this.tableFieldClick[field].cell.onclick) {
this.tableFieldClick[field].cell.onclick(obj)
}
// if (this.tableFields_obj[column.property]) {
// var tableField = this.tableFields_obj[column.property];
// if (tableField.iscellelclick) {
// let obj = {
// row: row,
// column: column,
// cell: cell,
// event: event
// }
// this.$emit('cell-el-click', obj);
// }
// }
// else {
// let obj = {
// row: row,
// column: column,
// cell: cell,
// event: event
// }
// this.$emit('cell-el-click', obj);
// }
},
// cellValClick(obj) {
// this.$emit('cell-click', obj);
// },
cellValMouseenter(obj) {
this.$emit('cell-val-mouseenter', obj);
},
cellValMouseleave(obj) {
this.$emit('cell-val-mouseleave', obj);
},
// 全选复选框选择或取消事件
allSelectionChange(selection) {
},
// 行复选框选择或取消事件
rowSelectionChange(selection, row) {
let selected = selection.length && selection.indexOf(row) !== -1
if (!selected) { // 取消选中
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += row[id_field];
})
// 如果共享文件夹中有，则从共享文件夹中删除
if (this.selectedMap[e_id_val]) {
this.selectedList.remove(this.selectedMap[e_id_val]);
delete this.selectedMap[e_id_val];
}
}
},
// 当选择项发生变化时会触发该事件
handleSelectionChange(selection) {
this.selection_cnt = selection.length;
if (this.isshowShoppingcart) { // 有共享文件夹功能
if (selection.length == 0) { // 全部取消选中
var removeselection_map_ = {};
// 根据当前表格中的数据进行共享文件夹的删除
this.tableData.map(r=>{
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += r[id_field];
})
removeselection_map_[e_id_val] = r;
})
for (var key in removeselection_map_) {
var row_ = removeselection_map_[key];
if (this.selectedMap[key]) {
this.selectedList.remove(this.selectedMap[key]);
delete this.selectedMap[key];
}
}
}
else { // 存在选中行
// 遍历选中行，并根据唯一字段组判断是否在共享文件夹中，若没有则添加到共享文件夹
var selection_map_ = {};
selection.map(r=>{
var e_id_val = "";
this.selectedIdByFields.map(id_field=>{
e_id_val += r[id_field];
})
selection_map_[e_id_val] = r;
})
for (var key in selection_map_) {
var row_ = selection_map_[key];
if (!this.selectedMap[key]) {
this.selectedMap[key] = row_;
this.selectedList.unshift(row_);
}
}
}
}
this.$emit('selection-change', selection);
},
hTableEmptySelect() {
var ref = this.href;
this.$refs[ref].clearSelection();
},
editDataRow(code, scope){
if (code == "edit") {
this.$emit('edit-data', scope);
}
else if (code == "delete") {
this.$emit('del-data', scope);
}
},
cellInputChange(scope) {//row, column, $index 和 store（table 内部的状态管理）
let field = scope.column.property;
this.$emit('cell-input-change', scope);
},
cellSelectChange(scope) {
let field = scope.column.property;
this.$emit('cell-select-change', scope);
},
cellButtonClick(scope) {
let field = scope.column.property;
this.$emit('cell-button-click', scope);
},
querySearch(obj) {
this.$emit('cell-query-search', obj);
},
createFilter(queryString) {
return (restaurant) => {
return (restaurant.value.toLowerCase().indexOf(queryString.toLowerCase()) === 0);
};
},
// showpopup(scope) {
// let field = scope.column.property;
// this.$emit('cell-show-popup', scope);
// },
tableFieldsList(t, fields_) {
var me = this;
if (t.children) {
this.tableFieldsList(t.children, fields_);
}
else {
if(this.isArray(t)) {
t.map(e=>{
me.tableFieldsList(e, fields_);
})
}
else {
fields_.push(t);
}
return fields_
}
},
getSummaries(param) {
var me = this;
const { columns, data } = param;
const sums = [];
var sumfields = {};
var issumfields = false;
var tableFields_ = [];
this.tableFields.map(e=>{
tableFields_ = me.tableFieldsList(e, tableFields_);
});
tableFields_.map(e=>{
if (e.istablesum) {
sumfields[e.field] = e;
issumfields = true;
}
});
if (issumfields) {
columns.forEach((column, index) => {
if (index === 0) {
sums[index] = '汇总';
return;
}
if (sumfields[column.property]) {
const values = data.map(item => Number(item[column.property]));
if (!values.every(value => isNaN(value))) {
sums[index] = values.reduce((prev, curr) => {
const value = Number(curr);
if (!isNaN(value)) {
return prev + curr;
}
else {
return prev;
}
}, 0);
var field = sumfields[column.property];
if (field.formatter && field.formatter=="formatter_money") {
sums[index] = formatter_money(null, null, sums[index]);
}
else {
sums[index] += '';
}
}
else {
sums[index] = '';
}
}
else sums[index] = '';
});
}
return sums;
},
// visibleChange(obj) {//下拉展开事件
// this.$emit("visible-change", obj);
// },
operate_(row, column, cellValue, index) {
if(cellValue === "create") {
return "新增数据";
}
else if(cellValue === "delete") {
return "删除数据";
}
else if(cellValue === "update") {
return "修改数据";
}
else return "";
},
status_(row, column, cellValue, index) {
if (cellValue == "working"){
return "正在审批";
}
else if(cellValue == "refuse") {
return "待修改";
}
else if(cellValue == "open") {
return "申请成功";
}
else if(cellValue == "close") {
return "撤销申请";
}
return "";
},
toggleSelection(array, iscancelselect) {
var ref = this.href;
if (iscancelselect && array) {
array.forEach(idORrow => {
var id_ = idORrow;
if (idORrow.id) {
id_ = idORrow.id
}
this.tableData.map(e=>{
if(id_ == e.id) {
this.$refs[ref].toggleRowSelection(e,false);
}
});
});
}
else if (array) {
array.forEach(idORrow => {
var id_ = idORrow;
if (idORrow.id) {
id_ = idORrow.id
}
this.tableData.map(e=>{
if(id_ == e.id) {
this.$refs[ref].toggleRowSelection(e,true);
}
});
});
} else {
this.$refs[ref].clearSelection();
}
},
onThisTableRefresh() {
// 如果有分页，从第一页查询
if (this.isPagination) {
this.zpagenum = 1
}
let page = {
pagesize: this.zpagesize,
pagenum: this.zpagenum
}
this.$emit('get-data', page);
},
toggleSelectionByRow(row) {
var ref = this.href;
this.$refs[ref].toggleRowSelection(row,true);
},
/* 每页条数变更事件 */
handleSizeChange(val) {
this.zpagesize = val;
let page = {
pagesize: this.zpagesize,
pagenum: this.zpagenum
}
this.$emit('get-data', page);
},
/* 页码变更事件*/
handleCurrentChange(val) {
this.zpagenum = val;
let page = {
pagesize: this.zpagesize,
pagenum: this.zpagenum
}
// if (!(this.tableAttr.isSelection || this.isSelection)) { // 如果不是多选则清空
// this.selectRowList = [];
// }
this.$emit('get-data', page);
},
}
});
/*********** h-form ************/
//单元格集合
Vue.component("h-cell-input", {//输入框
template:
'
'+
//只读
' '+
//文本域
''+
' '+
' '+
' '+
' '+
//可编辑
' '+
//文本域
''+
' '+
//文本域
''+
' '+
' '+
//this.tableFieldClick[fieldObj.field].input.onkeydown
' '+
' '+
' '+
' ',
props: {
formAttr: Object,
formDataData: {//表单全部数据
type: Object,
default: function(){
return {};
}
},
fromFieldObj: {
type: Object,
default: function(){
return {};
}
},
fieldObj: {//表单字段数据
type: Object,
default: function(){
return {};
}
},
tableFieldClick: {//字段对应的点击事件
type: Object,
default: function(){
return {
};
}
},
formFieldData: null,//字段值
dataIndex: {//字段值的下标
type: Number,
default: -1
},
dataId: {//字段值的id
type: String,
default: ""
},
disabled: {
type: Boolean,
default: false
},
},
data() {
return {
cellData: ""
}
},
computed: {
},
watch: {
},
mounted() {
var aa = this.fieldObj.field;
if (aa == "credit_amt"){
var bb = "";
}
this.cellData = this.formFieldData;
},
methods: {
onkeyup(keycode, val, fieldObj) {
if (this.tableFieldClick[fieldObj.field] && this.tableFieldClick[fieldObj.field].input && this.tableFieldClick[fieldObj.field].input.onkeyup){
this.tableFieldClick[fieldObj.field].input.onkeyup(keycode, val, fieldObj);
}
else if (fieldObj.inputkeys && val) {
if (fieldObj.inputkeys == "number") {//仅数字（正整数）
val = val.replace(/\D/g,'')
}
else if (fieldObj.inputkeys == "decimal") {//仅数字+点（正小数）
val = val.replace(/[^\d.]/g,'');
}
else if (fieldObj.inputkeys == "minus") {//仅数字+负号（正负整数）
//如果首位是“-”，则判断后续的值
if (val.substring(0, 1) == "-") {
var val_ = val.substring(1);
val_ = val_.replace(/\D/g,'')
val = "-" + val_
}
else {
val = val.replace(/\D/g,'')
}
}
else if (fieldObj.inputkeys == "minusdecimal") {//仅数字+负号+点（正负小数）
if (val.substring(0, 1) == "-") {
var val_ = val.substring(1);
val_ = val_.replace(/[^\d.]/g,'')
val = "-" + val_
}
else {
val = val.replace(/[^\d.]/g,'');
}
}
}
},
onkeydown(event, fieldObj) {
let key = event.key;
if (key == "Backspace" || key == "Delete") {//删除按键Backspace
return true
}
if (this.tableFieldClick[fieldObj.field] && this.tableFieldClick[fieldObj.field].input && this.tableFieldClick[fieldObj.field].input.onkeydown){
this.tableFieldClick[fieldObj.field].input.onkeydown(event, fieldObj);
}
else if (fieldObj.inputkeys) {
if (fieldObj.inputkeys == "number") {//仅数字（正整数）
var box = /^[0-9]*$/;//数值的正则表达式
if (!box.test(key)) {
event.returnValue = false
return false
}
else return true
}
else if (fieldObj.inputkeys == "decimal") {//仅数字+点（正小数）
var box = /^[0-9]*$/;//数值的正则表达式
if (key == ".") {//删除按键Backspace
return true
}
if (!box.test(key)) {
event.returnValue = false
return false
}
else return true
}
else if (fieldObj.inputkeys == "minus") {//仅数字+负号（正负整数）
var box = /^[0-9]*$/;//数值的正则表达式
if (key == "-") {//删除按键Backspace
return true
}
if (!box.test(key)) {
event.returnValue = false
return false
}
else return true
}
else if (fieldObj.inputkeys == "minusdecimal") {//仅数字+负号+点（正负小数）
var box = /^[0-9]*$/;//数值的正则表达式
if (key == "-" || key == ".") {//删除按键Backspace
return true
}
if (!box.test(key)) {
event.returnValue = false
return false
}
else return true
}
}
},
formchange(val, obj) {
if (typeof(val) == "string") {
//去除两端的空格
val = val.replace(/(^\s*)|(\s*$)/g, "");
//去除中间的回车换行
//this.formData[obj.field] = val = val.replace(/[\r\n]/g,"");
}
if (this.dataIndex > -1) {
this.formDataData[obj.field][this.dataIndex] = val;
}
else {
this.formDataData[obj.field] = val;
}
var obj_ = {
fieldobj: obj,
data: this.formDataData
}
if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].input && this.tableFieldClick[obj.field].input.onchange) {
this.tableFieldClick[obj.field].input.onchange(obj_);
}
// this.$emit("form-change", obj_);
},
remoteMethod(query, fieldObj) {
var fromFieldsObj_ = clone(this.fromFieldObj);
var fromFieldObj_ = fromFieldsObj_[fieldObj.field];
var obj = {
query: query,
fieldObj: fieldObj
}
if (query !== '') {
this.$emit('remote-method', obj);
} else {
fieldObj.options = [];
}
},
}
});
Vue.component("h-cell-select", {//下拉选择器的单元格
template://clearable
'
'+
//只读
// '{{typeof (hdisabled) != \'undefined\'}}{{hdisabled}}'+
// '{{typeof (disabled) != \'undefined\'}}{{disabled}}'+
// ' '+
' '+
' '+
' '+
' '+
' '+
' '+
//可编辑
' '+
' '+
' '+
' '+
' '+
//下拉单选
' '+
' '+
' '+
' '+
//下拉多选，没有下拉事件
' '+
' '+
' '+
' '+
//下拉多选，存在下拉事件
' '+
' '+
' '+
' '+
//可新增的下拉选择器
' '+
' '+
''+
'
'+
'新 增'+
'
'+
'
'+
'{{ item.label }}'+
// '{{ item.value }}'+
'
'+
'
'+
'{{ item.label }}'+
// '{{ item.value }}'+
'
'+
' '+
' '+
' '+
' '+
' '+
' '+
' '+
' '+
''+
'
'+
'{{ item.label }}'+
'{{ item.value }}'+
'
'+
'
',
props: {
formAttr: Object,
formDataData: {//表单全部数据
type: Object,
default: function(){
return {};
}
},
fromFieldObj: {
type: Object,
default: function(){
return {};
}
},
fieldObjt: {//表单字段数据
type: Object,
default: function(){
return {};
}
},
tableFieldClick: {//字段对应的点击事件
type: Object,
default: function(){
return {
};
}
},
formFieldData: null,//字段值
dataIndex: {//字段值的下标
type: Number,
default: -1
},
dataId: {//字段值的id
type: String,
default: ""
},
disabled: {
type: Boolean,
default: false
},
"formlanguage": {//表单语言
type: String,
default: "zh"
},
},
data() {
return {
hCellRefresh: true,
cellData: "",
fieldObj: {},
hdisabled: false,
formlanguage_map: {
zh: {
select: "请选择",
begin: "开始日期",
end: "结束日期",
to: "至"
},
en: {
select: "Select",
begin: "begin",
end: "end",
to: "to"
},
},
}
},
computed: {
},
watch: {
formFieldData() {
this.hCellRefresh = false;
this.$nextTick(function() {
this.hCellRefresh = true;
})
},
fieldObjt() {
this.fieldObj = clone(this.fieldObjt);
}
},
created() {
this.hdisabled = this.disabled;
this.fieldObj = clone(this.fieldObjt);
},
mounted() {
this.fromFieldObj;
this.fieldObj;
this.cellData = this.formFieldData;
},
methods: {
selectChange(val, obj) {
if (this.dataIndex > -1) {
this.formDataData[obj.field][this.dataIndex] = val;
}
else {
this.formDataData[obj.field] = val;
}
let me = this;
if (obj.selectchildren) {
obj.selectchildren.map(e=>{
let tableFieldsFormat_ = me.tableFieldsFormat;
tableFieldsFormat_.map(item => {
item.children.map(item2 => {
if (item2.field.toLowerCase().indexOf(e.toLowerCase()) > -1) {
if(item2.ismultiple || item2.type == "selectmultiple") {
me.formDataData[e] = [];
}
else {
me.formDataData[e] = "";
}
}
});
});
});
}
var optionsObj = {};
var value_ = "value";
if (obj.props && obj.props.value) {
value_ = obj.props.value;
}
else if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].select && this.tableFieldClick[obj.field].select.valuekey) {
value_ = this.tableFieldClick[obj.field].select.valuekey;
}
if (obj.options) {
obj.options.map(o=>{
optionsObj[o[value_]] = o;
})
}
// var selectoption = optionsObj[val];
var obj_ = {
fieldobj: obj,
// selectoption: selectoption,
data: this.formDataData
}
// 如果是数组值，是不返回当前选中项的
if (!Array.isArray(val)) {
obj_.selectoption = optionsObj[val] || {};
}
//let field = scope.column.property;
if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].select && this.tableFieldClick[obj.field].select.onchange) {
this.tableFieldClick[obj.field].select.onchange(obj_, function() {
me.$emit("form-change", obj_);
});
}
this.$emit("select-change", obj_);
this.isRefresh = false;
this.isRefresh = true;
},
visibleChange(isshow, obj, row) {//下拉展开事件
if (isshow) {
var me = this;
var fieldObj = clone(this.fieldObj);
if (this.tableFieldClick[fieldObj.field] && this.tableFieldClick[fieldObj.field].visible && this.tableFieldClick[fieldObj.field].visible.onchange) {
this.tableFieldClick[fieldObj.field].visible.onchange(fieldObj, row, function(obj_) {
// 如果有级联的字段需要刷新，此功能则不能用，因此作废
// fieldObj.options = obj_.options;
// me.fieldObj = clone(fieldObj)
});
}
// this.$emit("visible-change", fieldObj, row, function(obj_) {
// fieldObj.options = obj_.options;
// me.fieldObj = clone(fieldObj)
// /* me.hCellRefresh = false;
// me.$nextTick(function() {
// me.hCellRefresh = true;
// }) */
// });
}
},
// remoteMethod(query, fieldObj) {
// //var fromFieldsObj_ = clone(this.fromFieldObj);
// //var fromFieldObj_ = fromFieldsObj_[fieldObj.field];
// var obj = {
// query: query,
// fieldobj: fieldObj
// }
// if (query !== '') {
// this.$emit('remote-method', obj);
// } else {
// fieldObj.options = [];
// }
// },
remoteMethod(inputstring, fieldObj) {
var me = this;
var obj_ = {
fieldobj: fieldObj,
data: this.formDataData,
inputstring: inputstring
}
if (inputstring && this.tableFieldClick[fieldObj.field] && this.tableFieldClick[fieldObj.field].select && this.tableFieldClick[fieldObj.field].select.onQuerySearch) {
this.tableFieldClick[fieldObj.field].select.onQuerySearch(obj_,function(inputoptions) {
me.$set(fieldObj, "options", inputoptions);
});
}
else {
fieldObj.options = [];
}
},
selectClear(obj) {
if (this.dataIndex > -1) {
this.formDataData[obj.field][this.dataIndex] = "";
}
else {
this.formDataData[obj.field] = "";
}
var obj_ = {
fieldobj: obj,
data: this.formDataData
}
this.$emit("select-clear", obj_);
},
selectoptionoperate(type, obj) {
if (this.dataIndex > -1) {
this.formDataData[obj.field][this.dataIndex] = "";
}
else {
this.formDataData[obj.field] = "";
}
var obj_ = {
type: type,
fieldobj: obj,
data: this.formDataData
}
this.$emit("select-option-operate", obj_);
},
}
});
Vue.component("h-cell", {//表单单元格
template:
'
'+
''+
//数据前面加的
//前面加复选框
'| '+
'{{fieldObj.checkbox_text}} '+
' | '+
''+
''+
' {{formDataFace[fieldObj.isstamp]}} '+
' | '+
/* 前缀 */
''+
'{{fieldObj.prefix}}'+
' | '+
//正常数据
''+
''+
'{{fieldObj.prefix_span}}'+
' '+
//单选框含其它类型的输入框
' '+
' '+
'{{r.value}}'+
'{{fieldObj.fieldotherlabel ? fieldObj.fieldotherlabel : \'其它\'}} '+
''+
''+
' '+
' '+
//单选框
' '+
' '+
'{{r.value}}'+
''+
//单选框时的其它录入
// ''+
// ' '+
' '+
//值的数据类型数组（strlist: 字符串数组，objlist: 对象数组）
' '+
' '+
//第一个数据值
' '+
''+
''+
'| '+
//下拉选择器
' '+
//Tag 标签
//span
//输入
' '+
' | '+
// ''+
// //添加
// '添加'+
// ' '+
// ' | '+
' '+
''+
'| '+
//添加
'继续添加'+
' '+
' | '+
' '+
' '+
' '+
//遍历其它值，如果数组中不止一个值时
' '+
' '+
' '+
''+
''+
'| '+
//下拉选择器
' '+
//Tag 标签
//span
//输入
' '+
' | '+
// ''+
// //删除
// '删除'+
// ' '+
// ' | '+
' '+
''+
'| '+
//删除
'删 除'+
' '+
' | '+
' '+
' '+
' '+
' '+
' '+
' '+
//值的数据类型数组（strlist: 字符串数组，objlist: 对象数组）
' '+
' '+
//第一个数据值
' '+
''+
''+
'| '+
//表单
' '+
' '+
' | '+
// ''+
// //添加
// '添加'+
// ' '+
// ' | '+
' '+
''+
'| '+
// '删 除'+
' '+
// ' '+
//添加
'继续添加'+
' '+
' | '+
' '+
' '+
' '+
//遍历其它值，如果数组中不止一个值时
' '+
' '+
' '+
''+
''+
'| '+
//表单
' '+
' '+
' | '+
// ''+ //text-align: end;
// //删除
// '删除'+
// ' '+
// ' | '+
' '+
''+
'| '+
//删除
'删 除'+
' '+
//添加
'继续添加'+
' '+
' | '+
' '+
' '+
' '+
' '+
' '+
' '+
//数字
''+
' '+
//复选框（单个）
'{{fieldObj.label}}'+
' '+
//复选框（多项，值是数组，显示和值一样）
' '+
'{{o}} '+
' '+
//复选框（多项，值是数组，显示和值不一样）
' '+
''+
' 全选'+
' '+
'{{o.value}} '+
' '+
' '+
' '+
' '+
' '+
//复选框（多项，将选项按组分类）
' '+
'全选'+
' '+
'{{o.name}} '+
''+
' '+
'{{oc.value}} '+
' '+
' '+
' '+
' '+
//复选框（多项，每项选中后会有后续数据需要填写）
' '+
''+
'{{o.value}}'+
''+
''+//&& formData[o.checkbox_field]
//表单
' '+
' '+
''+
''+
' '+
//只读的且存在格式函数
''+
' {{formDataFace[fieldObj.field]}}'+
' '+
//input录入
' '+
/* 原input录入
''+
' '+
*/
//文本域
/* ''+
' '+ */
// 输入框可搜索(可用)
' '+
' '+
'{{ item[(tableFieldClick[fieldObj.field] && tableFieldClick[fieldObj.field].input && tableFieldClick[fieldObj.field].input.valuekey) ? tableFieldClick[fieldObj.field].input.valuekey : fieldObj.field] }} '+
' '+
'{{ item[f_tag] }} '+
' '+
' '+
' '+
//带输入建议的输入框
' '+
//日期
''+
' '+
//月份
''+
' '+
//年
''+
' '+
//日期段
''+
' '+
//数字范围
''+
''+
''+
''+
'| '+
' '+
' | '+
''+
'{{fieldObj.suffix}}'+
' | '+
' '+
' '+
''+
'-'+
''+
''+
''+
'| '+
' '+
' | '+
''+
'{{fieldObj.suffix}}'+
' | '+
' '+
' '+
''+
''+
//字符串范围
''+
''+
''+
''+
'| '+
' '+
' | '+
''+
'{{fieldObj.suffix}}'+
' | '+
' '+
' '+
''+
'-'+
''+
''+
''+
'| '+
' '+
' | '+
''+
'{{fieldObj.suffix}}'+
' | '+
' '+
' '+
''+
''+
//没有属性名称
''+
'{{fieldObj.formatter ? formDataFace[fieldObj.field] : formData[fieldObj.field]}}'+
'{{fieldObj.formatter ? formDataFace[fieldObj.field] : formData[fieldObj.field]}}'+
' '+
''+
' '+
' '+
'{{fieldObj.formatter ? formDataFace[fieldObj.field] : formData[fieldObj.field]}}'+
'{{fieldObj.formatter ? formDataFace[fieldObj.field] : formData[fieldObj.field]}}'+
' '+
' '+
' ' +
' ' +
//'{{formData[fieldObj.field]}}'+
' '+
' '+
' ' +
' '+
//'{{formData[fieldObj.field]}}'+
' '+
' ' +
''+
' @change="formvisiblechange($event, fieldObj)"'+
'>'+
''+
' '+
''+
' '+
//' @blur="formchange($event, fieldObj)"'+
// '>'+
''+
' '+
''+
''+
''+
'新 增'+
' '+
''+
''+
'{{ data.label }}'+
' ({{ data.children.length }}) '+
''+
''+
''+
' {{formData[fieldObj.field] == \'T\' ? fieldObj.activevalue : fieldObj.inactivevalue}}'+
' '+
' {{formData[fieldObj.field]}}'+
' '+
' '+
' '+
'{{fieldObj.formatter ? formDataFace[fieldObj.field] : formData[fieldObj.field]}}'+
'{{fieldObj.formatter ? formDataFace[fieldObj.field] : formData[fieldObj.field]}}'+
' '+
' '+
' '+
' '+
' '+
' '+
' | '+
/* 弹出popup是否可编辑 */
''+
''+
// 输入框可搜索(可用)
' '+
' '+
' {{ item[(tableFieldClick[fieldObj.field] && tableFieldClick[fieldObj.field].input && tableFieldClick[fieldObj.field].input.valuekey) ? tableFieldClick[fieldObj.field].input.valuekey : fieldObj.field] }} '+
' '+
'{{ item[f_tag] }} '+
' '+
' '+
' '+
''+
// ''+
// '{{fieldObj.popup_field ? formData[fieldObj.popup_field] : formDataFace[fieldObj.field]}} '+
// '{{fieldObj.popup_field ? formData[fieldObj.popup_field] : formData[fieldObj.field]}} '+
// ''+
' | '+
' '+
''+
' '+
' '+
/* ' {{formData[fieldObj.field]}} '+ */
' | '+
//''+
//' | '+
/* 后缀 */
''+
' '+
'{{fieldObj.suffix}}'+
' '+
' | '+
''+
' '+
'{{fieldObj.suffix}}'+
' '+
' | '+
/* 说明(isvalexplain_br:是否在字段下面显示) */
''+
'{{fieldObj.appendix}}'+
' | '+
/* ''+
' '+
' | '+ */
// ''+
// ' '+
// ' | '+
// (tableFieldClick[fieldObj.field] && tableFieldClick[fieldObj.field].popup && tableFieldClick[fieldObj.field].popup.onEmpty)
// ''+
' | '+
''+
'{{formData[fieldObj.field]}}'+
' | '+
''+
' '+
' | '+
''+
'{{fieldObj.buttonname}} {{fieldObj.buttonsuffix}} '+
' | '+
//附件上传
''+
''+
''+
''+
'| '+
'{{formData[fieldObj.field]}}'+
' '+
' | '+
''+
//只有存在数据时显示此按键（查看）
// ''+
// '查看下载 '+
// ''+
//存在数据且不只读时显示此按键（编辑删除事件）
''+
'删除附件 '+
''+
//没有数据且不只读时显示此按键（上传）
''+
'附件上传 '+
''+
' '+
' | '+
' '+
' '+
' | '+
''+
//多附件上传
''+
''+
''+
//不只读时显示此按键（上传）
''+
'| '+
'附件上传 '+
' '+
' | '+
' | '+
' '+
''+
''+
'| '+
'{{file_obj.file_name}}'+
' '+
''+
' '+
'{{file_obj.file_tag}}'+
''+
' | '+
''+
//存在数据且不只读时显示此按键（编辑删除事件）
''+
'删除附件 '+
''+
' | '+
' '+
''+
''+
' '+
''+
' '+
''+
//不只读时显示此按键（上传）
''+
''+
''+
''+
''+
''+
'| '+
' '+
'{{file_obj.file_name}}'+
''+
' '+
'{{file_obj.file_tag}}'+
''+
' | '+
''+
//存在数据且不只读时显示此按键（编辑删除事件）
''+
'删除附件 '+
''+
' | '+
' '+
' '+
'附件详情'+
''+
''+
''+
' '+
''+
' | '+
''+
' '+
'附件上传 '+
' | '+
' '+
' '+
' | '+
''+
''+
''+
''+
//存在数据且不只读时显示此按键
''+
'{{buttonobj.buttonname}} '+
''+
//只有存在数据时显示此按键
''+
'{{buttonobj.buttonname}} '+
''+
//没有数据且不只读时显示此按键
''+
'{{buttonobj.buttonname}} '+
''+
//一直显示此按键
''+
'{{buttonobj.buttonname}} '+
''+
//默认不设置类型时，不只读时显示此按键，不管是否存在数据
''+
'{{buttonobj.buttonname}} '+
''+
//'{{buttonobj.buttonname}} '+
//'{{buttonobj.buttonname}} '+
''+
' | '+
''+
'可用返利 :'+
'
'+
// //字段对比
// ''+
// ''+
// '{{fieldObj.example}}
'+
// ''+
// ''+
// ' | '+
//对比
''+
''+
' '+
//el-icon-c-scale-to-original
'vs'+
''+
' | '+
//样例
''+
''+
'{{fieldObj.example}}
'+
''+
''+
''+
''+
' | '+
'
'+
'
',
props: {
formAttr: Object,
fromFieldObj: {//表单字段是否编辑
type: Object,
default: function(){
return {};
}
},
fieldObj: {//表单字段数据
type: Object,
default: function(){
return {};
}
},
formFieldData: {//字段值，可能是字符串、布尔、字符串数组、对象数组
type: Object,
default: function(){
return {};
}
},
tableFields: {
type: Array,
default: function(){
return [];
}
},
tableFieldClick: {//字段对应的点击事件
type: Object,
default: function(){
return {
};
}
},
notvalunit: {//是否不保留单位/后缀占位符
type: Boolean,
default: true
},
isOldContrast: {//是否对比差异
type: Boolean,
default: false
},
contrastMode: {//对比方式//fieldContrast字段对比，formContrast表单整体对比
type: String,
default: "fieldContrast"
},
fileListShowType: {//多附件的显示方式//formshow/popover
type: String,
default: "formshow"
},
formDataOld: {//对比差异的历史数据
type: Object,
default: function(){
return {};
}
},
isEndColspan: {//是否最后一行自动铺满
type: Boolean,
default: true
},
formData: {//表单数据
type: Object,
default: function(){
return {};
}
},
href: {//无数据的图片
type: String,
default: "form1"
},
disabled: {
type: Boolean,
default: false
},
width: {
type: String,
default: "100%"
},
// formDataFace: {//表单数据
// type: Object,
// default: function(){
// return {};
// }
// },
},
data() {
return {
hCellRefresh: true,
tableFieldsFormat: [],
//fromFieldObj: {},
formFieldsObj: {},
record: null,
formDataData: {},
formDataFace: {},
listIndex0: 0,
formnotdisabled: false,
selectother: "other",
notselectother: ""
}
},
computed: {
},
watch: {
formData(newName, oldName) {
let me = this;
if (newName[this.fieldObj.field] != oldName[this.fieldObj.field] ) {
this.hCellRefresh = false;
this.$nextTick(function() {
this.hCellRefresh = true;
})
}
if (this.fieldObj.type == "popup") {
this.$emit("form-change", this.fieldObj);
}
if (this.formData) {
// this.record = new Record(me);
// this.record.setData(this.formData);
// this.formDataData = this.formData;
// this.rebate_available = this.formData.rebate_available;
// this.formDataFace = this.record.getFace();
//var formDataFace_ = this.record.getFace();
this.formDataFace = {}
for (var prop in this.formData) {
var fieldMeta = this.formFieldsObj[prop];
if (!fieldMeta) {
continue;
}
var value = this.formData[prop];
if (fieldMeta.inputtype && fieldMeta.inputtype == "year") {
value = value.toString()
this.formData[prop] = value;
}
var e = fieldMeta;
if (e.formatter) {
//formatpattern 格式设置（可以是小数位数。也可以是时间、日期的格式）
if (e.formatter == "formatter_json") {
var json_ = {};
if (e.formatterjson) {
//说明是对应关系
json_ = e.formatterjson;
}
else if (e.formatpattern){
//根据formatpattern获取公用的对应关系，从字典中获取,字典数据从数据库获取
var map_ = window.top.Dictionary.getMap(e.formatpattern);
json_ = e.formatterjson = clone(map_);
}
else if (!e.formatpattern && e.optionsgroup){
//根据optionsgroup下拉组名获取公用的对应关系，从字典中获取,字典数据从数据库获取
var map_ = window.top.Dictionary.getMap(e.optionsgroup);
json_ = e.formatterjson = clone(map_);
}
this.formDataFace[prop] = formatter_json(null, null, value, null, json_);
}
else if (e.formatter == "formatter_money") {
var digit = e.formatpattern;//小数位数，默认2位
this.formDataFace[prop] = formatter_money(null, null, value, null, digit);
}
else if(e.formatter == "formatter_date") {
var format = e.formatpattern;//日期格式，默认"yyyy-MM-dd"
this.formDataFace[prop] = formatter_date(null, null, value, null, format);
}
else if(e.formatter == "formatter_float") {
var digit = e.formatpattern;//小数位数，默认2位
this.formDataFace[prop] = formatter_float(null, null, value, null, digit);
}
else if(e.formatter == "formatter_percent") {
var digit = e.formatpattern;//小数位数，默认2位
this.formDataFace[prop] = formatter_percent(null, null, value, null, digit);
}
else if(e.formatter == "formatter_split") {
var format = e.formatpattern;//拼接的字段格式 format = "#{name}-{name}%"
this.formDataFace[prop] = formatter_split(this.formData, null, value, null, format);
}
else if(e.formatter == "formatter_prefixorunit") {
var prefix = e.prefix;//前缀
var unit = e.suffix;//后缀或单位
this.formDataFace[prop] = formatter_prefixorunit(null, null, value, null, prefix, unit);
}
}
}
}
},
fieldObj() {
if (this.fieldObj.iscellrefresh) {
this.hCellRefresh = false;
this.$nextTick(function() {
this.hCellRefresh = true;
})
}
if (this.fieldObj) {
/* this.hCellRefresh = false;
this.$nextTick(function() {
this.hCellRefresh = true;
}) */
}
},
},
mounted() {
let me = this;
this.formData;
this.disabled;
this.fieldObj;
this.tableFieldClick;
if (this.tableFields) {
let tableFields_ = clone(this.tableFields);
let formFieldsObj_ = {};
for (var r=0; r
{
item.children.map(item2 => {
if (item2.field.toLowerCase().indexOf(fieldobj.field.toLowerCase()) > -1) {
item2.options = result;
}
});
});
this.tableFieldsFormat = tableFieldsFormat_;
},
// visibleChange(isshow, obj, row) {//下拉展开事件
// if (isshow) {
// var me = this;
// var fieldObj = clone(this.fieldObj);
// this.$emit("visible-change", fieldObj, row, function(obj_) {
// fieldObj.options = obj_.options;
// me.fieldObj = clone(fieldObj)
// /* me.hCellRefresh = false;
// me.$nextTick(function() {
// me.hCellRefresh = true;
// }) */
// });
// }
// },
/* visibleChange(isshow, obj, row) {//下拉展开事件
if (isshow) {
this.$emit("visible-change", obj, row);
}
}, */
remoteMethod(query, fieldObj) {
var fromFieldsObj_ = clone(this.fromFieldObj);
var fromFieldObj_ = fromFieldsObj_[fieldObj.field];
var obj = {
query: query,
fieldObj: fieldObj
}
if (query !== '') {
this.$emit('remote-method', obj);
} else {
fieldObj.options = [];
}
},
numberKeyupChange(key) {
/* let b = new RegExp("^[1-9]\d*\.\d*|[1-9]\d*$").test(key.target.value);
var reg = /^\d+$|^\d*\./g;
b = reg.test(key.target.value);
if (!b) {
key.target.value = '';
} */
},
openformvisible(val, obj) {
var ref = obj.field + obj.visiblefield;
this.$refs[ref].$el.click();
//this.$refs[ref]._data.dropDownVisible = !this.$refs[ref]._data.dropDownVisible;
},
formvisiblechange(val, obj) {
var obj_ = {
fieldobj: obj,
data: this.formData
}
if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].val && this.tableFieldClick[obj.field].val.onchange) {
this.tableFieldClick[obj.field].val.onchange(obj_);
}
// this.$emit("form-change", obj_);
},
formchange(val, obj) {
if (typeof(val) == "string") {
//去除两端的空格
this.formData[obj.field] = val = val.replace(/(^\s*)|(\s*$)/g, "");
//去除中间的回车换行
//this.formData[obj.field] = val = val.replace(/[\r\n]/g,"");
}
var obj_ = {
fieldobj: obj,
data: this.formData
}
/* */
if (obj.type == "cascader") {
var optionsObj = {};
var value_ = "value";
if (obj.props && obj.props.value) {
value_ = obj.props.value;
}
obj.options.map(o=>{
optionsObj[o[value_]] = o;
})
// 如果是数组值，是不返回当前选中项的
if (!Array.isArray(val)) {
obj_.selectoption = optionsObj[val] || {};
}
else if (Array.isArray(val) && val.length == 1) {
obj_.selectoption = optionsObj[val[val.length - 1]];
}
}
// 组件内部事件
this.$emit("form-change", obj_);
// 组件与页面的交互
if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].val && this.tableFieldClick[obj.field].val.onchange) {
this.tableFieldClick[obj.field].val.onchange(obj_);
}
},
handleCheckAllChange(val, fieldObj, formData) {
var code_ = [];
if (fieldObj.type == 'checkboxobj') {
if (val) {
fieldObj.options.map(o=>{
code_.push(o.code)
});
}
}
else if (fieldObj.type == 'checkboxobjgroup') {
if (val) {
fieldObj.options.map(o=>{
o.children.map(oc=>{
code_.push(oc.code)
})
});
}
}
formData[fieldObj.field] = code_
},
isformcheckboxchange(val, obj) {
var obj_ = {
fieldobj: obj,
data: this.formData
}
this.$emit("form-checkbox-change", obj_);
},
ischeckboxchange(val, obj) {
obj.disabled = !val;
},
ischeckboxchangeToEdit(val, obj) {
obj.disabled = !val;
this.cellFaceClick(obj);
},
cellFaceClick(fieldObj) {
var fromFieldObj_ = clone(this.fromFieldObj);
if (fromFieldObj_[fieldObj.field].isEdit){
return;
}
this.record.setEditData(this.formData);
this.record.apply();
this.formDataFace = this.record.getFace();
for (var field in fromFieldObj_) {
fromFieldObj_[field].isEdit = false;
}
if (!fieldObj.disabled && !this.disabled && !this.formAttr.disabled) {
fromFieldObj_[fieldObj.field].isEdit = true;
}
this.fromFieldObj = fromFieldObj_;
},
cellVisibleChange(obj, row, callback) {
this.$emit("visible-change", obj, row,callback);
},
formRemoteMethod(obj) {
this.$emit('remote-method', obj);
},
cellFormChange(obj) {
/* this.hCellRefresh = false;
this.$nextTick(function() {
this.hCellRefresh = true;
}) */
this.$emit("form-change", obj);
},
selectChange(obj) {
this.$emit("select-change", obj);
},
selectClear(obj) {
this.$emit("select-clear", obj);
},
selectOptionOperate(obj) {
this.$emit("select-option-operate", obj);
},
cellselectoptionoperate(type, obj) {
if (this.dataIndex > -1) {
this.formDataData[obj.field][this.dataIndex] = "";
}
else {
this.formDataData[obj.field] = "";
}
var obj_ = {
type: type,
fieldobj: obj,
data: this.formDataData
}
this.$emit("select-option-operate", obj_);
},
/* selectChange(val, obj) {
this.formDataData[obj.field] = val;
let me = this;
if (obj.selectchildren) {
obj.selectchildren.map(e=>{
let tableFieldsFormat_ = me.tableFieldsFormat;
tableFieldsFormat_.map(item => {
item.children.map(item2 => {
if (item2.field.toLowerCase().indexOf(e.toLowerCase()) > -1) {
if(item2.ismultiple) {
me.formDataData[e] = [];
}
else {
me.formDataData[e] = "";
}
}
});
});
});
}
var obj_ = {
fieldobj: obj,
data: this.formDataData
}
this.$emit("select-change", obj_);
this.isRefresh = false;
this.isRefresh = true;
}, */
// querySearch(queryString, cb, scope, tableField) {
// let field = scope.column.property;
// var obj = {
// queryString: queryString,
// cb: cb,
// scope: scope,
// tableField: tableField
// }
// var inputoptions = tableField.inputoptions;
// var results = queryString ? inputoptions.filter(this.createFilter(queryString)) : inputoptions;
// cb(results);
// this.$emit('cell-query-search', obj);
// },
querySearch(inputstring, cb, fieldObj) {
var obj_ = {
fieldobj: fieldObj,
data: this.formData,
inputstring: inputstring
}
if (inputstring && this.tableFieldClick[fieldObj.field] && this.tableFieldClick[fieldObj.field].input && this.tableFieldClick[fieldObj.field].input.onQuerySearch) {
this.tableFieldClick[fieldObj.field].input.onQuerySearch(obj_,function(inputoptions) {
cb(inputoptions);
});
}
else {
cb([]);
}
},
autocompleteChange(val, obj) {
var obj_ = {
selectoption: val || {},
fieldobj: obj,
data: this.formData
}
if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].input && this.tableFieldClick[obj.field].input.onchange) {
this.tableFieldClick[obj.field].input.onchange(obj_);
}
},
inputSelectChange(val, obj) {
var obj_ = {
selectoption: val || {},
fieldobj: obj,
data: this.formData
}
if (this.tableFieldClick[obj.field] && this.tableFieldClick[obj.field].input && this.tableFieldClick[obj.field].input.onselectchange) {
this.tableFieldClick[obj.field].input.onselectchange(obj_);
}
},
createFilter(queryString) {
return (restaurant) => {
return (restaurant.value.toLowerCase().indexOf(queryString.toLowerCase()) === 0);
};
},
showexample(fieldObj) {
var me = this;
// var fieldObj = clone(this.fieldObj);
if (this.tableFieldClick[fieldObj.field] && this.tableFieldClick[fieldObj.field].example && this.tableFieldClick[fieldObj.field].example.onshow) {
this.tableFieldClick[fieldObj.field].example.onshow(fieldObj, function(obj_) {
// fieldObj.example_imgurl = obj_.example_imgurl;
me.$set(fieldObj, "example_imgurl", obj_.example_imgurl)
// me.fieldObj = clone(fieldObj)
});
}
},
checkForm() {//检验通过true 否false
var bo_sum = true;
for (var c_ref in this.$refs) {
var bo_ = true;
if (this.isArray(this.$refs[c_ref])) {
if(this.$refs[c_ref].length > 0){
bo_ = this.$refs[c_ref][0].checkForm();
}
}else if(this.$refs[c_ref] && this.$refs[c_ref].checkForm) {
bo_ = this.$refs[c_ref].checkForm()
}
else {
// bo_ = this.$refs[c_ref].checkForm()
}
bo_sum = bo_ & bo_sum;
}
return bo_sum;
/* var ref = this.href;
var bo_ = true;
this.$refs[ref].validate((valid) => {
if (valid) {
} else {
bo_ = false;
}
});
return bo_; */
},
isArray(r){
return Object.prototype.toString.call(r)== '[object Array]';
},
}
});
//单个表单
Vue.component("h-newform-a", {//表单组件
template:
''+
'
'+
' '+
' '+
'| '+
' '+
' '+
' '+
' '+
' '+
' '+
' '+
//isColon:是否存在"："
' '+
' '+
// ' '+
// ''+
// ' '+
// ''+
// ''+
// ' '+
/* 说明 */
'{{fieldObj.appendix}}'+
' '+
//版本对比的数据，所以不能编辑(整个表单对比)
' '+
' '+
/* 说明 */
'{{fieldObj.appendix}}'+
' '+
' '+
' | '+
'
'+
'
'+
' '+
'
'+
' '+
'