qd_hezheng
/
qdhezheng-license-web
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5d050a8cb7'
${ noResults }
qdhezheng-license-web/public/v1/system/base/datasource.js

4017 lines
120 KiB
Raw Blame History Escape

This file contains ambiguous Unicode characters!

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

(function (win) {
/////////////////////////////////////////////
///global variable
////////////////////////////////////////////
var ID_PROPERTY = '$id';
var ROW_SELECT_COLNAME = '$is_sel';
var Global = win.Store;
var hasValue = function (o) {
if (o !== 0 && !o) {
return false;
}
return true;
};
var getFormatter = function (name) {
if (Slick && Slick.Formatters) {
return Slick.Formatters[name];
}
return null;
};
var toStrLines = function (arr) {
var msgs = [];
for (var i = 0, len = arr.length; i < len; i++) {
var elem = arr[i];
if (msgs.indexOf(elem) === -1) {
msgs.push(elem);
}
}
return arr.join('<br>').replace(/\n/g, '<br>');
};
var serialEnumValues = function (data, sep) {
if (!data) return [];
var result = []
sep = sep || '';
for (var name in data) {
var item = {
key: name,
value: name + sep + data[name]
}
result.push(item);
}
return _.sortBy(result, 'key');
};
var isObjectValueEqual = function (a, b) {
var aProps = Object.getOwnPropertyNames(a);
var bProps = Object.getOwnPropertyNames(b);
if (aProps.length != bProps.length) {
return false;
}
for (var i = 0; i < aProps.length; i++) {
var propName = aProps[i];
if (a[propName] !== b[propName]) {
return false;
}
}
return true;
}
var checkDuplicate = function (datas, data) {
var flag = false;
for (var i = 0, length = datas.length; i < length; i++) {
if (isObjectValueEqual(datas[i], data)) {
flag = true;
break;
}
}
return flag;
}
function equalIgnoreCase(a, b) {
a = String(a).toUpperCase()
b = String(b).toUpperCase()
return a === b
}
function toUpperKey(o) {
if (!o || Object.keys(o).length === 0) {
return {}
}
var result = {}
Object.keys(o).forEach(k => {
result[k.toUpperCase()] = o[k]
})
return result
}
////////////////////////////////////////////
///DataColumn 数据列
/**
* 数据列，用于表示数据源上的列
* @param {Object} dataSrc 数据源
*/
function DataColumn(dataSrc) {
var self = this;
self.dataSrc = dataSrc;
self.isDataColumn = true;
self.isInit = false;
Global.eventuality(self);
}
/**
* 数据列初始化，主要是初始化相应的字典属性,只执行一遍
* @param {Object} dictCol 服务器返回的字典信息
* @return {[type]} [description]
*/
DataColumn.prototype.init = function (dictCol) {
if (self.isInit) {
return;
}
var col = this;
//数据相关
col.fieldName = dictCol.fieldName;
col.dataRightCode = dictCol.dataRightCode;
col.dataRightType = dictCol.dataRightType;
col.defaultValue = dictCol.defaultValue;
col.paraValue = dictCol.defaultValue;
col.isEmptyField = dictCol.isEmptyField;
col.isQrySele = dictCol.isQrySele;
col.isStrictRef = dictCol.isStrictRef;
col.isCalc = dictCol.isCalc;
col.isRequired = dictCol.isRequired;
col.isEditLimit = dictCol.isEditLimit;
col.isEditable = dictCol.isEditable;
col.match = dictCol.match;
col.refObj = dictCol.refObj;
col.refField = dictCol.refField;
col.refFieldName = dictCol.refFieldName;
col.refSeparator = dictCol.refSeparator;
col.refType = dictCol.refType;
col.refEditWhere = dictCol.refEditWhere;
col.setRule = dictCol.setRule;
col.statType = dictCol.statType;
col.extParams = dictCol.extParams;
col.dataType = col.isCalc ? '1' : dictCol.dataType;
col.dataWidth = dictCol.dataWidth || 0;
col.dataDec = dictCol.dataDec || 0;
col.procParaType = dictCol.procParaType;
col.isPrimaryKey = dictCol.isPrimaryKey;
//界面相关
col.dispScale = dictCol.dispScale;
col.dispFormat = dictCol.dispFormat;
col.dispName = dictCol.dispName;
col.dispIndex = dictCol.dispIndex;
col.dispPosition = dictCol.dispPosition;
col.dispWidth = dictCol.dispWidth;
col.headerWidth = dictCol.headerWidth;
col.labelWidth = dictCol.labelWidth;
col.hint = dictCol.hint;
col.editStyle = dictCol.editStyle;
col.isZeroSpace = dictCol.isZeroSpace;
col.pageId = dictCol.pageId;
col.refCols = dictCol.refCols;
col.isReadonly = false; //是否只读列
col.header = dictCol.header;
col.precision = dictCol.precision;
col.keyBoardType = dictCol.keyBoardType;
};
/**
* 设置属性值
* @param {[type]} property [description]
* @param {[type]} value [description]
*/
DataColumn.prototype.set = function (property, value) {
this[property] = value;
this.onPropertyChanged(property);
};
/**
* 获取属性值
* @param {[type]} property [description]
* @return {[type]} [description]
*/
DataColumn.prototype.get = function (property) {
return this[property];
};
/**
* 属性改变通知
* @param {String} property 属性名
* @return {[type]} [description]
*/
DataColumn.prototype.onPropertyChanged = function (property) {
this.fire('onPropertyChanged', {
propertyName: property
});
};
/**
* 获取列是否只读
*/
DataColumn.prototype.getReadOnly = function () {
return !this.isEditable || this.isReadonly;
}
/**
* 校验数据
* @param {DataRow} row 所在行
* @param {Object} value 新值
* @return {Boolean} 是否通过
*/
DataColumn.prototype.validator = function (row, value) {
if (row && row.validator) {
return row.validator(this, value);
}
return true;
};
/**
* 获取显示内容
* @param {DataRow} row 所在行
* @return {string} 显示内容
*/
DataColumn.prototype.getText = function (row) {
if (!row) return null;
var name = this.fieldName;
var value = row[name];
var refValue = row[name + '$'];
if (hasValue(refValue) && this.refType != Global.Enums.RefType.NONE) {
var sep = this.refSeparator || '';
return value + sep + refValue;
} else {
if (value instanceof Date) {
return TypeUtil.toDateString(value)
}
return hasValue(value) ? value.toString() : '';
}
};
/**
* 按照列的配置，获取value对应的实际值
* @param {[type]} value [description]
* @return {String} [description]
*/
DataColumn.prototype.getValue = function (value) {
//null或者undefined，则直接返回null
if (value !== '' && !hasValue(value)) {
return null;
}
//数字处理逻辑
if (this.dataType == Global.Enums.DataType.NUMBER) {
if (typeof value === 'string') {
value = value.trim();
//处理分隔符
if (this.refSeparator) {
let index = value.indexOf(this.refSeparator);
if (index > -1) {
value = value.slice(0, index);
}
}
}
return Number(value) || 0;
}
//非数字处理逻辑
if (typeof value !== 'string') {
value = value.toString();
}
value = value.trim();
//处理分隔符
if (this.refSeparator && this.refObj &&
this.dataType != Store.Enums.DataType.DATETIME &&
this.editStyle != Store.Enums.EditStyle.DATE) {
let index = value.indexOf(this.refSeparator);
if (index > -1) {
value = value.slice(0, index);
}
}
if (this.dataType == Store.Enums.DataType.DATETIME && value && value.length <= 10 && value.indexOf('-') > -1) {
value = value + ' 00:00:00';
}
return value;
};
/**
* 是否是表参照，包括属性参照和表参照
* @returns {boolean}
*/
DataColumn.prototype.isTableRef = function () {
return this.refType == Global.Enums.RefType.TABLE || this.refType == Global.Enums.RefType.PROP;
};
/**
* 是否是枚举参照
* @returns {boolean}
*/
DataColumn.prototype.isEnumRef = function () {
return this.refType == Global.Enums.RefType.ENUM;
};
/**
* 是否是无参照
* @returns {boolean}
*/
DataColumn.prototype.isNoneRef = function () {
return this.refType == Global.Enums.RefType.NONE;
};
/**
* 设置dr上当前列的参照值
* @param {Object} dr dataRow
*/
DataColumn.prototype.setRefValue = function (dr, value) {
var item = this.getRefItem();
if (item) {
//表参照处理
if (this.isTableRef() && this.refFieldName) {
dr[this.fieldName + '$'] = item[this.refFieldName.toUpperCase()];
}
//枚举参照处理
if (this.isEnumRef()) {
var refValue = item[value];
dr[this.fieldName + '$'] = refValue;
}
} else {
if (dr.hasOwnProperty(this.fieldName + '$')) {
dr[this.fieldName + '$'] = null;
}
}
};
/**
* 获取参照值
* @param {null|String} name
* @return {null|String}
*/
DataColumn.prototype.getRefValue = function (name) {
if (this.refItem) {
if (!name) {
name = this.refField || '';
}
let refValue = this.refItem[name.toUpperCase()]
if (refValue === undefined) {
refValue = null
}
return refValue;
} else {
return null;
}
};
/**
* 获取列的默认显示格式
* @return {[type]} 显示格式，已预置
*/
DataColumn.prototype.getFormatter = function () {
var defaultFormatter = null;
switch (this.editStyle) {
case Global.Enums.EditStyle.CHECKBOX:
defaultFormatter = getFormatter('Checkbox');
break;
case Global.Enums.EditStyle.TEXT:
defaultFormatter = getFormatter('Text');
break;
case Global.Enums.EditStyle.REFERENCE:
defaultFormatter = getFormatter('Reference');
break;
case Global.Enums.EditStyle.DECIMAL:
defaultFormatter = getFormatter('Decimal');
break;
case Global.Enums.EditStyle.DATETIME:
defaultFormatter = getFormatter('DateTime');
break;
default:
break;
//预留
}
defaultFormatter = getFormatter(this.dispFormat) || defaultFormatter;
var formatter = this.dataSrc.onGetColumnFormatter(this, defaultFormatter);
return formatter || null;
};
/**
* 获取参照内容。枚举值获取的是数据，表参照获取的是行集合
* @param {DataRow} row 数据行
* @param {Boolean} ignoreValue 忽略当前value的约束
* @return {*} [description]
*
*/
DataColumn.prototype.loadRefData = function (row, value, ignoreValue, isEdit) {
//如果当前参照内容未发生改变，则不再重复获取数据
//只有在值处理时，才会需要跳过
if (!ignoreValue && this.refField &&
this.refItem &&
this.refItem.$owner === row[ID_PROPERTY] &&
this.getRefValue() == value) {
return;
}
this.dataSrc.loadDefaultRefData(row, this, value, ignoreValue, isEdit);
};
/**
* 获取参照数据
* @returns {*|Array}
*/
DataColumn.prototype.getRefData = function () {
return this.refData;
}
/**
* 设置参照数据
* @param {null|Array} data
*/
DataColumn.prototype.setRefData = function (data) {
if (data) {
this.refData = data;
} else {
this.refData = [];
}
}
/**
* 获取参照列表
* @param {DataColumn} col
* @return {[Array]}
*/
function getRefTableList(col) {
var self = col,
result = [];
if (self.refData && self.refField) {
for (var i = 0; i < self.refData.length; i++) {
var row = self.refData[i];
var text = row[self.refField.toUpperCase()];
var item = {
key: text
};
if (self.refFieldName) {
var sep = self.refSeparator || '';
text = text + sep + row[self.refFieldName.toUpperCase()];
}
item.value = text;
result.push(item);
}
}
return result;
};
/**
* 获取参照显示列表
* @return Array [description]
*/
DataColumn.prototype.getRefList = function () {
var self = this;
//枚举
if (self.isEnumRef()) {
return serialEnumValues(self.refData, self.refSeparator);
}
//表参照
if (self.isTableRef()) {
return getRefTableList(self);
}
return [];
};
/**
* 获取当前参照信息
* @returns {null|*}
*/
DataColumn.prototype.getRefItem = function () {
return this.refItem;
};
/**
* 设置参照信息
* @param {null|*} item
* @param {DataRow} [dr]
*/
DataColumn.prototype.setRefItem = function (item, dr) {
if (item) {
this.refItem = item;
if (dr) {
this.refItem.$owner = dr[ID_PROPERTY];
}
} else {
this.refItem = null;
}
}
/**
* 获取参照表的字典编码
* @returns {String}
*/
DataColumn.prototype.getRefObjCode = function () {
if (this.refType == Global.Enums.RefType.TABLE) {
return this.refObj;
}
if (this.refType == Global.Enums.RefType.PROP) {
var refObjCol = this.dataSrc.getColumn(this.refObj);
if (refObjCol) {
return refObjCol.getRefObjCode();
}
}
return '';
}
/**
* 展示弹出窗体
* @param {DataRow} row
* @param {String} text
* @param {Boolean} isEdit
* @param {Function} callback
* @return {*}
*/
DataColumn.prototype.showDlg = function (dr, text, isEdit, callback) {
var args = {
dataSrc: this.dataSrc,
row: dr,
col: this,
text: text,
refParam: this.getRefParam(dr, text, isEdit, true),
isEdit: isEdit,
callback: callback
};
return this.dataSrc.onUserRefDlg(args);
};
/**
* 展示多选弹出窗体
* @param {DataRow} row
* @param {String} text
* @param {Boolean} isEdit
* @param {Function} callback
* @return {*}
*/
DataColumn.prototype.showMultiDlg = function (dr, text, isEdit, callback) {
var args = {
dataSrc: this.dataSrc,
row: dr,
col: this,
text: text,
refParam: this.getRefParam(dr, text, isEdit, true),
isEdit: isEdit,
callback: callback
};
return this.dataSrc.onUserMultiRefDlg(args);
};
/**
* 获取参照查询参数
* @param {DataRow} dr [description]
* @param {Object} value [description]
* @param {Boolean} isEdit
* @param {Boolean} ignoreValue
* @return {{fieldName: *, uiObjCode: *, refField: *, refFieldName: *, refType: *, refObj: *, userRefWhere, value: Object, D: *, ignoreValue: boolean}} [description]
*/
DataColumn.prototype.getRefParam = function (dr, value, isEdit, ignoreValue) {
var self = this;
var refParam = {
fieldName: self.fieldName,
refCols: self.refCols,
uiObjCode: self.dataSrc.uiObjCode,
userRefWhere: self.dataSrc.onGetUserRefColumnWhere(dr, self, isEdit),
value: value,
D: isEdit && dr ? dr.getData() : {},
ignoreValue: !!ignoreValue
};
if (self.dataSrc._parentRelation) {
var masterRow = self.dataSrc._parentRelation.master.currentRow;
refParam.M = masterRow ? masterRow.getData() : {};
}
return refParam;
};
///////////////////////////////////////////////////////////////
///DataRow 数据行
/**
* 数据行，用于数据源存放数据
* @param {Object} dataSrc 数据源
* @param {Boolean} nodefault 是否处理默认值
*/
function DataRow(dataSrc, nodefault) {
this.isDataRow = true;
this.dataSrc = dataSrc;
this.dataRowState = Global.Enums.DataRowState.DETACHED;
this._origin = {};
this._prevValues = {}
this._updating = false;
this._valueLocking = {};
this[ID_PROPERTY] = Date.now();
this._errors = {
data: [],
//获取列错误
getError: function (colName) {
var len = this.data.length;
for (var i = 0; i < len; i++) {
if (this.data[i].column == colName) {
return this.data[i].errMsg;
}
}
return null;
},
//设置列错误
setError: function (colName, value) {
var index = -1,
len = this.data.length;
for (var i = 0; i < len; i++) {
if (this.data[i].column == colName) {
index = i;
break;
}
}
if (index < 0) {
var err = {
column: colName,
errMsg: value,
id: colName + Date.now()
}
this.data.push(err);
} else {
this.data[index].id = colName + Date.now();
this.data[index].errMsg = value;
}
},
//清空错误
clearError: function (colName) {
var index = -1,
len = this.data.length;
for (var i = 0; i < len; i++) {
if (this.data[i].column == colName) {
index = i;
break;
}
}
if (index >= 0) {
this.data.splice(index, 1);
}
},
//清空所有错误
clearAll: function () {
this.data = [];
},
//获取错误数
getLength: function () {
return this.data.length;
},
/**
* 检查当前错误集合是否已经减少
* @param errs 旧错误集合
* @returns {boolean}
*/
less: function (errs) {
if (this.getLength() == 0) {
return true;
}
if (errs.getLength() < this.getLength()) {
return false;
} else if (errs.getLength() == this.getLength()) {
for (let i = 0; i < this.data.length; i++) {
let err = this.data[i],
err1 = errs.data[i];
if (err.id !== err1.id) {
return false;
}
}
} else {
for (let i = 0; i < this.data.length; i++) {
let err = this.data[i];
let hit = false;
//检测是否能在errs找到原错误，找到则继续查找下一个错误
for (let j = 0; j < errs.data.length; j++) {
if (errs.data[j].id === err.id) {
hit = true;
break;
}
}
//找不到错误，则认为错误发生了变化
if (!hit) {
return false;
}
}
}
return true;
}
};
this.init(nodefault);
}
/**
* 比较r是否是当前行
* @param {[type]} r [description]
* @return {[type]} [description]
*/
DataRow.prototype.equals = function (r) {
return this === r;
};
/**
* 初始化数据源，默认根据列数生成属性
* @param {[type]} nodefault [description]
* @return {[type]} [description]
*/
DataRow.prototype.init = function (nodefault) {
if (nodefault) {
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
this[col.fieldName] = null;
}
} else {
this.setDefaultValue();
}
};
DataRow.prototype.beginUpdate = function () {
this._updating = true;
};
DataRow.prototype.endUpdate = function () {
this._updating = false;
};
/**
* 设置默认值
*/
DataRow.prototype.setDefaultValue = function () {
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
this[col.fieldName] = col.dataType === Global.Enums.DataType.NUMBER ? 0 : null;
}
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
//获取默认值，会经过业务类的处理
var dfValue = this.dataSrc.getDefaultValue(this, col);
if (dfValue || dfValue === 0) {
this.setColumnText(col, dfValue);
}
}
};
/**
* 加载数据，数据来自于data，通常是服务获取来的数据
* @param {DataRow|Object} data 数据
* @return {[type]} [description]
*/
DataRow.prototype.loadData = function (data) {
var self = this;
data = toUpperKey(data)
//服务器返回的数据，列名都是小写
for (var j = 0; j < self.dataSrc.columns.length; j++) {
var col = self.dataSrc.columns[j];
if (data.hasOwnProperty(col.fieldName.toUpperCase())) {
self[col.fieldName] = data[col.fieldName.toUpperCase()];
}
if (data.hasOwnProperty(col.fieldName.toUpperCase() + '$')) {
self[col.fieldName + '$'] = data[col.fieldName.toUpperCase() + '$'];
}
if (self[col.fieldName] && col.dataType === Global.Enums.DataType.DATETIME) {
self[col.fieldName] = new Date(Number(self[col.fieldName]))
}
}
if (self.dataSrc) {
var ds = self.dataSrc;
ds.onCollectChanged(Global.Enums.CollectionChangedAction.REPLACE, this);
ds.columns.forEach(function (col) {
ds.updateParent(col);
});
}
};
/**
* 接受当前对行的增加、修改
* @return {DataRow}
*/
DataRow.prototype.acceptChanges = function () {
var self = this;
//接受操作，具体内容：
//1、修改行状态为UNCHANGED无修改状态
//2、备份数据，作为原始数据
//3、删除行做accept没有意义
if (this.dataRowState == Global.Enums.DataRowState.DELETED) {
return this;
}
this.dataRowState = Global.Enums.DataRowState.UNCHANGED;
//find out dataSrc originRow
var dataSrcOriginRow = this.dataSrc._originRows[self[ID_PROPERTY]];
this._origin = {};
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var c = this.dataSrc.columns[i];
this._origin[c.fieldName] = this[c.fieldName];
this._origin[c.fieldName + '$'] = this[c.fieldName + '$'];
if (dataSrcOriginRow) {
dataSrcOriginRow[c.fieldName] = this[c.fieldName];
dataSrcOriginRow[c.fieldName + '$'] = this[c.fieldName + '$'];
}
}
return this;
};
/**
* 丢弃
* @return {[type]} [description]
*/
DataRow.prototype.rejectChanges = function () {
//丢弃修改
//放弃所有的修改，只对修改行有用
if (this.dataRowState == Global.Enums.DataRowState.MODIFIED) {
this.dataRowState = Global.Enums.DataRowState.UNCHANGED;
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var c = this.dataSrc.columns[i];
this[c.fieldName] = this._origin[c.fieldName];
this[c.fieldName + '$'] = this._origin[c.fieldName + '$'];
}
}
this._errors.clearAll();
return this;
};
DataRow.prototype.beginTransaction = function () {
if (!this.transData) {
this.transData = $.extend(true, {}, this);
return 0;
}
return 1;
};
DataRow.prototype.getPrevValue = function (fieldName) {
if (fieldName === null || fieldName === undefined) { return undefined }
return this._prevValues[fieldName]
};
DataRow.prototype.commit = function (id) {
if (id === 0) {
this.transData = null;
}
};
DataRow.prototype.rollBack = function (id) {
if (id !== 0) {
return;
}
//丢弃修改
//放弃某个节点之后的修改
let originRow = this.transData;
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var c = this.dataSrc.columns[i];
this[c.fieldName] = originRow[c.fieldName];
this._prevValues = origin._prevValues || {}
this[c.fieldName + '$'] = originRow[c.fieldName + '$'];
}
this._errors = originRow._errors;
this.dataRowState = originRow.dataRowState;
this.dataSrc.onCollectChanged(Global.Enums.CollectionChangedAction.REPLACE, this);
this.transData = null;
return this;
};
/**
* 获取行上某列的错误信息
* @param {String} colName 列名
* @return {[type]} [description]
*/
DataRow.prototype.getColumnError = function (colName) {
if (typeof colName === 'object') {
colName = colName.fieldName;
}
return this._errors.getError(colName);
};
/**
* 设置行上某列的错误信息
* @param {[type]} colName [description]
* @param {[type]} errMsg [description]
*/
DataRow.prototype.setColumnError = function (colName, errMsg, noShow) {
//赋值错误也作为行修改的标识
if (this.dataRowState == Global.Enums.DataRowState.UNCHANGED) {
this.dataRowState = Global.Enums.DataRowState.MODIFIED;
}
if (typeof colName === 'object') {
colName = colName.fieldName;
}
console.log(errMsg);
this._errors.setError(colName, errMsg);
if (!this._updating && !noShow) {
setTimeout(function () {
//如果页面已经有了提示框则不弹提示框
if (!$(".messager-window").length) {
Global.messager.err(errMsg)
}
}, 120);
}
return this;
};
/**
* 清除行上某列的错误
* @param {[type]} colName [description]
* @return {[type]} [description]
*/
DataRow.prototype.clearColumnError = function (colName) {
if (typeof colName === 'object') {
colName = colName.fieldName;
}
this._errors.clearError(colName);
};
/**
* 获取行上是否存在错误
* @return {Boolean} [description]
*/
DataRow.prototype.hasError = function () {
return this._errors.getLength() > 0;
};
/**
* 设置列值，不会触发校验，仍然触发值改变通知
* @param {String} col [description]
* @param {Object} value [description]
*/
DataRow.prototype.setColumnValue = function (col, value) {
var dc = this.dataSrc.getColumn(col);
if (dc === null) {
Global.throwException(Global.MSG.COL_NOT_FOUND, 'setColumnValue');
}
//修改状态， 还原状态，通知内容修改
this._prevValues[dc.fieldName] = this[dc.fieldName]
this[dc.fieldName] = value;
this.clearColumnError(dc);
if (this.dataRowState == Global.Enums.DataRowState.UNCHANGED) {
this.dataRowState = Global.Enums.DataRowState.MODIFIED;
}
this.dataSrc.onValueChanged(this, dc);
// 更新子表合计
if (this.dataRowState != Global.Enums.DataRowState.DETACHED) {
this.dataSrc.updateParent(col);
}
return this;
};
/**
* 设置列的参照名称
* @param {[type]} col 列名或者列
* @param {string} refValue 参照名称
*/
DataRow.prototype.setColumnRefValue = function (col, refValue) {
var dc = this.dataSrc.getColumn(col);
if (dc === null) {
Global.throwException(Global.MSG.COL_NOT_FOUND, 'setColumnRefValue');
}
this[dc.fieldName + '$'] = refValue;
return this;
};
/**
* 判断值改变
* @param newValue 新值
* @param oldValue 旧值
*/
function isValueChanged(newValue, oldValue) {
if (newValue == oldValue) {
return false;
}
if (newValue == null && oldValue == '') {
return false;
}
if (oldValue == null && newValue == '') {
return false;
}
return true;
}
/**
* 检查器，完成值校验、赋值、赋值后处理
* @param {DataColumn} col [description]
* @param {Object} value [description]
* @return {Boolean} [description]
*/
DataRow.prototype.validator = function (col, value, callback) {
if (typeof col === 'string') {
col = this.dataSrc.getColumn(col);
}
try {
//检查值是否锁定，锁定则退出
var lock = this._valueLocking[col.fieldName];
if (lock) return true;
this._valueLocking[col.fieldName] = true;
//获取需要保存的值，如果未改变则退出
value = col.getValue(value);
var err = this.getColumnError(col);
if (!err && !isValueChanged(value, this.getColumnValue(col))) {
return true;
}
//基本校验，包括参照内容的获取
var bRet = this.dataSrc.validateColumn(this, col, value);
if (bRet) {
//赋值以及相关值
return this.calcColumnValue(col, value);
}
return false;
} finally {
delete this._valueLocking[col.fieldName];
}
};
/**
* 处理与col列相关联的列的值
* @param {DataColumn} col
* @param {Object} value 新值
* @return {Boolean} [description]
*/
DataRow.prototype.calcColumnValue = function (col, value) {
try {
var id = this.beginTransaction();
//参照值
col.setRefValue(this, value);
//带出其他字段
this.setColumnValue(col, value);
var isOk = true;
//关联参照，处理属性参照和属性参照的表参照
if (col.refType === Global.Enums.RefType.TABLE || (col.refType === Global.Enums.RefType.PROP && col.isStrictRef)) {
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var c = this.dataSrc.columns[i];
//处理属性参照
//或处理属性参照的表参照
if ((c.refType == Global.Enums.RefType.PROP && c.refObj === col.fieldName) ||
(col.refType == Global.Enums.RefType.PROP && col.refObj === c.fieldName)) {
var value = col.getRefValue(c.refField);
c.setRefData(col.getRefData());
c.setRefItem(col.getRefItem());
this.setColumnText(c, value);
var err = this.getColumnError(c);
if (err) {
isOk = false;
break;
}
}
}
}
if (!isOk) {
//回滚
this.rollBack(id);
return false;
}
this.dataSrc.onFieldChanged(this, col);
if (!this._errors.less(this.transData._errors)) {
col.$colErr = this.getColumnError(col);
this.rollBack(id);
if (col.$colErr) {
this.setColumnError(col, col.$colErr, true);
delete col.$colErr;
}
return false;
}
this.commit(id);
if (this.dataRowState != Global.Enums.DataRowState.DETACHED) {
this.dataSrc.updateParent(col);
}
return true;
} catch (ex) {
this.setColumnError(col, ex.toString());
this.rollBack(id);
return false;
}
};
/**
* 设置校验值，触发业务校验，通知界面更新
* @param {String|DataColumn} col
* @param {Object} value
*/
DataRow.prototype.setColumnText = function (col, value) {
if (typeof col === 'string') {
col = this.dataSrc.getColumn(col);
}
if (!col)
Global.throwException(Global.MSG.COL_NOT_FOUND, 'setColumnText');
return this.validator(col, value);
};
/**
* 获取列显示值
* @param {DataColumn} col ，支持列名
* @return {String} code-name
*/
DataRow.prototype.getColumnText = function (col) {
if (typeof col === 'string') {
col = this.dataSrc.getColumn(col);
if (col === null) {
return '';
}
}
return col.getText(this);
};
/**
* 获取列值
* @param {String} col 列名
* @return {[type]} [description]
*/
DataRow.prototype.getColumnValue = function (col) {
return typeof col === 'string' ? this[col] : this[col.fieldName];
};
/**
* 删除该行
* @param needConfirm 是否需要询问
*/
DataRow.prototype.delete = function (needConfirm) {
return this.dataSrc.deleteRow(this, needConfirm);
};
/**
* 获取打印用的行数据
* 1.主要区别getData方法是添加了枚举的value-description展示
* @return {[type]} [description]
*/
DataRow.prototype.getPrintData = function () {
var data = {};
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
// if (Global.Enums.RefType.ENUM == col.refType) {
if (this[col.fieldName + '$']) {
data[col.fieldName] = this[col.fieldName] + col.refSeparator + this[col.fieldName + '$'];
} else {
data[col.fieldName] = this[col.fieldName] == null ? '' : this[col.fieldName];
}
data['old_' + col.fieldName] = this._origin[col.fieldName];
data['$state'] = this.dataRowState;
}
return data;
};
/**
* 获取带有行原始值的数据对象，不会带有方法
* @return {type}
*/
DataRow.prototype.getData = function () {
var data = {};
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
data[col.fieldName] = this[col.fieldName] instanceof Date ? this[col.fieldName].getTime() : this[col.fieldName];
data['old_' + col.fieldName] = this._origin[col.fieldName] instanceof Date ? this._origin[col.fieldName].getTime() : this._origin[col.fieldName];
data['$state'] = this.dataRowState;
}
return data;
};
/**
* 行校验
* @param {Function} onerror 错误回调
* @return {boolean} 是否通过
*/
DataRow.prototype.validate = function (onerror) {
return this.dataSrc.validateDataRow(this, onerror);
};
/**
* 检查必填字段
* @return {boolean} 是否通过
*/
DataRow.prototype.checkRequired = function () {
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
if (col.isRequired && (this[col.fieldName] === null || this[col.fieldName] === '')) {
this.setColumnError(col.fieldName, col.dispName + Global.MSG.VALUE_REQUIRE);
}
};
return !this.hasError();
};
/**
* 获取行上所有错误的文本信息
* @return {string}
*/
DataRow.prototype.getErrors = function () {
var msg = '';
for (var i = 0; i < this._errors.data.length; i++) {
var err = this._errors.data[i].errMsg;
msg = msg + err + '\n';
}
return msg;
};
/**
* 获取该行上对应于某列的显示格式，通常用于网格使用
* @param {DataColumn} col
* @return {All}
*/
DataRow.prototype.getFormatter = function (col) {
return this.dataSrc.onGetRowFormatter(this, col);
};
DataRow.prototype.isEmpty = function () {
for (var i = 0; i < this.dataSrc.columns.length; i++) {
var col = this.dataSrc.columns[i];
if (col.isEmptyField && !hasValue(this[col.fieldName])) {
return true;
}
};
return false;
};
/////////////////////////////////////////////////////////////////
///主从关系类
/**
* 主从关系类
* @param {DataSource} master [description]
* @param {DataSource} detail [description]
* @param {String} masterColunmsStr [description]
* @param {String} detailColumnsStr [description]
*/
function DataRelation(master, detail, masterColunmsStr, detailColumnsStr) {
var self = this;
var masterColunms = typeof masterColunmsStr === 'string' ? masterColunmsStr.split(',') : null;
var detailColumns = typeof detailColumnsStr === 'string' ? detailColumnsStr.split(',') : null;
if (!masterColunms || !detailColumns || masterColunms.length != detailColumns.length) {
Global.throwException(Global.MSG.MASTERDETAIL_KEYERR, 'DataRelation');
}
this.master = master;
this.detail = detail;
this.masterColunms = masterColunms;
this.detailColumns = detailColumns;
//检查子表合计
this._totalMap = {};
this.master.columns.forEach(function (col) {
if (col.refType == Global.Enums.RefType.TOTAL && col.refObj == self.detail.uiObjCode) {
self._totalMap[col.refField] = col.fieldName;
}
});
/**
* 获取主从关系
* @return {[type]} [description]
*/
function getSchema(args) {
var schema = {
masterKey: self.masterColunms.toString(),
detailKey: self.detailColumns.toString(),
detail: self.detail.getSchemaData(args)
};
return schema;
}
/**
* 获取从表约束
* @param {[type]} dr [description]
* @return {[type]} [description]
*/
function getParams(dr) {
var p = {};
for (var i = 0; i < self.detailColumns.length; i++) {
var col = self.detailColumns[i];
p[col] = dr[self.masterColunms[i]];
}
return p;
}
/**
* 获取从表对应值
* @return {[type]} [description]
*/
function getDetailValue(detailCol) {
if (typeof detailCol !== 'string') {
detailCol = detailCol.fieldName;
}
//检查是否是关系键
var index = self.detailColumns.indexOf(detailCol);
if (index < 0) {
return null;
}
//检查主表当前行是否为空
if (!self.master.currentRow) {
return null;
}
return self.master.currentRow[self.masterColunms[index]];
}
function updateRelationValue(dr) {
if (dr.dataSrc !== self.master) {
return;
}
for (var j = 0, len = self.detail.rows.length; j < len; j++) {
var row = self.detail.rows[j];
for (var i = 0; i < self.detailColumns.length; i++) {
var detailCol = self.detailColumns[i];
var masterCol = self.masterColunms[i];
// 添加判断在增加时更新从表主键值。
var fieldValue = row[detailCol];
if (fieldValue == null || fieldValue == '' || fieldValue == '*'
|| row.dataRowState == Global.Enums.DataRowState.ADDED) {
row.setColumnText(detailCol, dr[masterCol]);
}
}
}
}
/**
* 字表合计
* @param {String|DataColumn} detailColName
*/
var aggregateDetail = function (detailColName) {
try {
if (detailColName instanceof DataColumn) {
detailColName = detailColName.fieldName;
}
var masterColName = self._totalMap[detailColName];
if (!masterColName) {
return;
}
var curRow = self.master.currentRow;
if (curRow) {
curRow.setColumnText(masterColName, getTotalValue(detailColName));
}
} catch (ex) {
console.log(ex);
}
}
/**
* 获取明细的合计值
* @param {String} colName
*/
function getTotalValue(colName) {
//遍历明细，赋值，以最后一个为准
var result = 0;
self.detail.rows.forEach(function (row) {
result = BigNumber.add(result, TypeUtil.toFloat(row[colName]));
});
return result;
}
_.extend(this, {
'getDetailValue': getDetailValue,
'getParams': getParams,
'getSchema': getSchema,
'updateRelationValue': updateRelationValue,
'aggregateDetail': aggregateDetail
});
}
/////////////////////////////////////////////////////
///数据源
/**
* 数据源，用于进行操作业务数据，影响界面和后台
* @param {[type]} opts [description]
*/
function DataSource(opts) {
this.columns = [];
this.rows = [];
this.currentRow = null;
this._deletedRows = [];
this._originRows = {};
this._childRelations = [];
this._parentRelation = null;
this._needUpdateTotalRows = true; //是否更新总行
this._totalRows = -1;
this._pageSize = -1;
this._pagenum = 0;
this._isOpened = true;
this._idSequence = {};
this._editable = false;
this._requireDetail = false;
this.isDataSource = true;
this.onlySaveCurrent = false;
this.fixQuery = {};
this.queryParamPlugin = null;
this._followMaster = true
Global.eventuality(this);
var defaultOpts = {
funcObjName: '',
funcObjCode: '',
allowDel: true,
allowEdit: true,
allowInsert: true,
detailkey: '',
fixedSearch: '',
isMaster: false,
isMultiPage: false,
isSaveRefresh: false,
isShowSelCol: false,
masterKey: '',
parentFuncObjName: '',
isShow: true
};
_.extend(defaultOpts, opts);
this.initFuncObj(defaultOpts);
}
////////////////
//Property Begin
/**
* 获取明细是否必填
* @return {Number} [description]
*/
DataSource.prototype.getRequireDetail = function () {
return this._requireDetail;
};
/**
* 设置是否明细是否必填
* @param {Boolean} value
*/
DataSource.prototype.setRequireDetail = function (value) {
this._requireDetail = value;
this.onPropertyChanged('RequireDetail');
};
/**
* 获取是否需要更新总行数
* @return {Number} [description]
*/
DataSource.prototype.getNeedUpdateTotalRows = function () {
return this._needUpdateTotalRows;
};
/**
* 设置是否更新总行数属性
* @param {[type]} value [description]
*/
DataSource.prototype.setNeedUpdateTotalRows = function (value) {
this._needUpdateTotalRows = value;
this.onPropertyChanged('NeedUpdateTotalRows');
};
/**
* 获取数据总行数
* @return {number}
*/
DataSource.prototype.getTotalRows = function () {
if (this._totalRows <= 0 && this.rows.length > 0) {
return this.rows.length
}
return this._totalRows < 0 ? 0 : this._totalRows;
};
DataSource.prototype.setTotalRows = function (value) {
this._totalRows = value;
this.onPropertyChanged('TotalRows');
};
/**
* 获取每页行树，用于分页
* @return {number}
*/
DataSource.prototype.getPageSize = function () {
return this._pageSize;
};
DataSource.prototype.setPageSize = function (value) {
this._pageSize = value;
this.onPropertyChanged('PageSize');
};
/**
* 获取当前页号，查看数据所在的页号
* @return {number}
*/
DataSource.prototype.getPagenum = function () {
return this._pagenum;
};
DataSource.prototype.setPagenum = function (value) {
this._pagenum = value;
this.onPropertyChanged('Pagenum');
};
DataSource.prototype.getEditable = function () {
return this._editable;
};
DataSource.prototype.setEditable = function (value) {
this._editable = value;
this.onPropertyChanged('Editable');
};
// 设置数据源最终搜索时用到的物理表名
DataSource.prototype.setSearchTableName = function (name) {
this._searchTableName = name;
};
DataSource.prototype.getSearchTableName = function () {
return this._searchTableName;
};
DataSource.prototype.setFollowMaster = function (value) {
this._followMaster = !!value
}
DataSource.prototype.getFollowMaster = function () {
return this._followMaster
}
//Property End
/////////////////////////////
/**
* 初始化功能对象字典
* @param {object} dict 服务器传过来的字典对象
* @return {object} this
*/
DataSource.prototype.initFuncObj = function (dict) {
this.funcCode = dict.funcCode;
this.name = dict.funcObjName;
this.uiObjCode = dict.funcObjCode;
this.allowDel = dict.allowDel;
this.allowEdit = dict.allowEdit;
this.allowInsert = dict.allowInsert;
this.detailKey = dict.detailKey;
this.fixedSearch = dict.fixedSearch;
this.isMaster = dict.isMaster;
this.isMultiPage = dict.isMultiPage;
this.isSaveRefresh = dict.isSaveRefresh;
this.isShowSelCol = dict.isShowSelCol;
this.isShow = dict.isShow;
this.masterKey = dict.masterKey;
this.parentObjName = dict.parentFuncObjName;
return this;
};
/**
* 初始化界面字典
* @param {object} dict 服务器传来的字典或者uiObjCode
* @return {object} this
*/
DataSource.prototype.initUIObj = function (dict) {
this.defaultOrder = dict.defaultOrder;
this.dataObjType = dict.dataObjType;
this.multiFields = dict.multiFields;
this.multiMsg = dict.multiMsg;
this.multiType = dict.multiType;
this.treeField = dict.treeField;
this.uiObjName = dict.uiObjName;
this.headers = dict.headers;
this.datasetName = dict.datasetName;
this.columns.names = {};
for (var i = 0; i < dict.columns.length; i++) {
var col = new DataColumn(this);
var dictCol = dict.columns[i];
col.init(dictCol);
this.columns.push(col);
this.columns.names[col.fieldName] = i;
}
return this;
};
function serialize(ds, type) {
var data = {
uiObjCode: ds.uiObjCode,
uiObjName: ds.uiObjName,
isMaster: ds.isMaster,
fieldList: [],
forPrint: []
};
for (var i = 0; i < ds.columns.length; i++) {
var col = ds.columns[i];
data.fieldList.push({
fieldName: col.fieldName,
fieldDes: col.dispName,
dataType: col.dataType,
dataWidth: col.dataWidth,
dataDec: col.dataDec,
hasRefColumn: (col.isTableRef() || col.isEnumRef()) ? '1' : '0'
});
}
if (type === '0') {
if (ds.currentRow) {
data.forPrint.push(ds.currentRow.getPrintData())
}
} else if (type === '1') {
for (var k = 0; k < ds.rows.length; k++) {
var row = ds.rows[k];
data.forPrint.push(row.getPrintData());
}
} else if (type === '2') {
for (var i = 0; i < ds.rows.length; i++) {
var row = ds.rows[i];
if (row.$is_sel) {
data.forPrint.push(row.getPrintData());
}
}
}
return data;
};
/**
* 获取打印数据
* @return {Array}
*/
DataSource.prototype.getPrintData = function () {
var self = this,
printData = [];
printData.push(serialize(self, '0'));
for (var j = 0; j < self.getDetailRelations().length; j++) {
var r = self.getDetailRelations()[j];
printData.push(serialize(r.detail, '1'));
}
return printData;
};
DataSource.prototype.getPrintAllSelectData = function () {
var self = this,
printData = [];
printData.push(serialize(self, '2'));
return printData;
};
/**
* 获取打印变量
* @return {Object}
*/
DataSource.prototype.getPrintVariables = function () {
var self = this;
return self.onGetPrintVariables();
};
/**
* 获取数据源上的指定列
* @param {DataColumn} col 列名，如果传入的是DataColumn，则直接返回
* @return {DataColumn|null} DataColumn或者null
*/
DataSource.prototype.getColumn = function (col) {
if (col) {
if (typeof col == 'string' && this.columns.names && this.columns.names.hasOwnProperty(col)) {
return this.columns[this.columns.names[col]];
}
if (col.isDataColumn && this.columns.indexOf(col) >= 0) {
return col;
}
}
return null;
};
/**
* 创建基于当前DataSource的行
* @return {[type]} [description]
*/
DataSource.prototype.newRow = function (noDefault) {
return new DataRow(this, noDefault);
}
/**
* 增加行到当前数据源,如果dr未指定，则自动添加一行
* @param {DataRow} [dr]
* @param noDefault 是否不需要m默认值
*/
DataSource.prototype.addRow = function (dr, noDefault) {
if (dr === undefined) {
dr = this.newRow(noDefault);
}
if (!this._maxId) {
this._maxId = 1;
}
dr[ID_PROPERTY] = this._maxId++;
this.rows.push(dr);
dr.dataRowState = Global.Enums.DataRowState.ADDED;
if (this._isOpened) {
this.onCollectChanged(Global.Enums.CollectionChangedAction.ADD, dr);
this.setCurrentRow(dr);
this.onRowAdded(dr);
var self = this;
this.columns.forEach(function (col) {
self.updateParent(col);
});
}
return dr;
}
DataSource.prototype.removeRow = function (dr) {
var self = this;
var index = self.rows.indexOf(dr);
if (index < 0) {
return;
}
this.rows.splice(index, 1);
this.columns.forEach(function (col) {
self.updateParent(col);
});
if (self._isOpened) {
self.onRowRemoved(dr);
self.onCollectChanged(Global.Enums.CollectionChangedAction.REMOVE, dr);
index = index - 1;
index = index > -1 ? index : 0;
self.setCurrentRow(index);
}
return self;
}
/**
* 删除行
* @param {DataRow} dr 要删除的行
* @param needConfirm 是否需要确认
*/
DataSource.prototype.deleteRow = function (dr, needConfirm) {
var index = this.rows.indexOf(dr);
if (index < 0) {
return null;
}
var self = this;
this.onRowDeleting(dr, needConfirm, function () {
dr.rejectChanges();
self.removeRow(dr);
for (var j = 0; j < self._childRelations.length; j++) {
var r = self._childRelations[j];
if (dr.hasOwnProperty(r.detail.name)) {
for (var i = 0; i < dr[r.detail.name].rows.length; i++) {
dr[r.detail.name].rows[i].dataRowState = Global.Enums.DataRowState.DELETED;
}
}
}
if (dr.dataRowState == Global.Enums.DataRowState.MODIFIED ||
dr.dataRowState == Global.Enums.DataRowState.UNCHANGED) {
dr.dataRowState = Global.Enums.DataRowState.DELETED;
self._deletedRows.push(dr);
}
self.onRowDeleted(dr);
});
};
DataSource.prototype.deleteAll = function () {
for (var i = this.rows.length; i > 0; i--) {
this.rows[i - 1].delete();
}
};
/**
* 清空数据。注意，clear后，所有数据都会销毁，包括删除的数据和原始数据
* 无法通过rejectChange操作还原
* @return {[type]} [description]
*/
DataSource.prototype.clear = function () {
//if (this.rows.length > 0) {
this.rows.splice(0);
//清空原始数据和删除数据
this._idSequence = {};
this._originRows = {};
this._deletedRows.splice(0);
this.setTotalRows(-1);
//this.setPagenum(0);
//this.setPageSize(-1);
this.setCurrentRow(null);
this.onCleared();
this.onCollectChanged(Global.Enums.CollectionChangedAction.RESET);
return this;
};
/**
* 接受修改
* @return {[type]} [description]
*/
DataSource.prototype.acceptChanges = function () {
this._originRows = {};
for (var i = 0, len = this.rows.length; i < len; i++) {
var dr = this.rows[i];
//主从从表数据
for (var j = 0, len1 = this._childRelations.length; j < len1; j++) {
var rel = this._childRelations[j];
delete dr[rel.detail.name];
}
dr.acceptChanges();
this._originRows[dr[ID_PROPERTY]] = _.clone(dr);
}
this._deletedRows.splice(0);
return this;
};
/**
* 快照当前数据，用于后续reset
* @return {[type]} [description]
*/
DataSource.prototype.snapData = function () {
var data = {};
data.origin = _.clone(this._originRows);
data.deleted = _.clone(this._deletedRows);
data.rows = _.clone(this.rows);
return data;
};
/**
* 获取变动行，包含删除行
* @param {Function} iteratee 处理方法
* @return {[type]} [description]
*/
DataSource.prototype.getChanges = function (iteratee) {
var self = this;
var changes = [];
this.ii = this.ii ? this.ii : 0;
//删除行数据
for (var k = 0; k < self._deletedRows.length; k++) {
var delRow = self._deletedRows[k];
changes.push(delRow);
if (iteratee) {
iteratee(delRow);
}
}
//本身修改数据
for (var i = 0; i < self.rows.length; i++) {
var row = self.rows[i]
if (row.dataRowState != Global.Enums.DataRowState.UNCHANGED && row.dataRowState != Global.Enums.DataRowState.DETACHED) {
changes.push(row);
if (iteratee) {
iteratee(row);
}
}
}
//检查父数据是否有需要提交的内容
var pr = self.getParentRelation();
if (pr) {
var masterRows = pr.master.getAllRows();
for (var j = 0; j < masterRows.length; j++) {
var mrow = masterRows[j];
if (mrow.hasOwnProperty(pr.detail.name)) {
for (var l = 0; l < mrow[pr.detail.name].rows.length; l++) {
var drow = mrow[pr.detail.name].rows[l];
if (drow.dataRowState != Global.Enums.DataRowState.UNCHANGED && drow.dataRowState != Global.Enums.DataRowState.DETACHED) {
changes.push(drow);
if (iteratee) {
iteratee(drow);
}
}
}
//删除行
if (mrow[pr.detail.name].deleted.length > 0) {
for (var l = 0; l < mrow[pr.detail.name].deleted.length; l++) {
var dDelRow = mrow[pr.detail.name].deleted[l];
if (dDelRow.dataRowState == Global.Enums.DataRowState.DELETED) {
changes.push(dDelRow);
if (iteratee) {
iteratee(dDelRow);
}
}
}
}
}
}
}
return changes;
};
/**
* 获取实际的数据，通常与rows一致，只有在多级从表情况下才会导致不一致。
* @param {[type]} first_argument [description]
* @return {[type]} [description]
*/
DataSource.prototype.getAllRows = function () {
var self = this;
var data = [];
//删除行数据
for (var k = 0; k < self._deletedRows.length; k++) {
var delRow = self._deletedRows[k];
data.push(delRow);
}
//本身修改数据
for (var i = 0; i < self.rows.length; i++) {
var row = self.rows[i]
data.push(row);
}
//检查父数据是否有需要提交的内容
var pr = self.getParentRelation();
if (pr) {
var masterRows = pr.master.getAllRows();
for (var j = 0; j < masterRows.length; j++) {
var mrow = masterRows[j];
if (mrow.hasOwnProperty(pr.detail.name)) {
for (var l = 0; l < mrow[pr.detail.name].rows.length; l++) {
var drow = mrow[pr.detail.name].rows[l];
data.push(drow);
}
}
}
}
return data;
};
/**
* 获取选择行
* @returns {Array}
*/
DataSource.prototype.getSelectedRows = function () {
var selected = [];
this.rows.forEach(function (item) {
if (item[ROW_SELECT_COLNAME]) {
selected.push(item);
}
});
return selected;
};
/**
* 放弃修改数据，取消修改
* @param {[type]} deep 是否深还原，即还原明细数据
* @return {[type]} [description]
*/
DataSource.prototype.rejectChanges = function (deep) {
this.rows = [];
var curIndex = -1;
var curRow = null;
//记录当前行的坐标
if (this.currentRow && (this.currentRow.dataRowState == Global.Enums.DataRowState.MODIFIED || this.currentRow.dataRowState == Global.Enums.DataRowState.UNCHANGED)) {
curIndex = this.currentRow[ID_PROPERTY];
}
//重置当前行
this.currentRow = null;
//还原数据
if (this._originRows) {
for (var i in this._originRows) {
var originRow = this._originRows[i];
var row = _.clone(originRow);
if (curIndex === row[ID_PROPERTY]) {
curRow = row;
}
row.rejectChanges();
this.rows.push(row);
}
}
this._deletedRows.splice(0);
//还原当前行，如果curIndex为-1，则还原后的当前行仍为null
this.currentRow = curRow;
this.onCollectChanged(Global.Enums.CollectionChangedAction.RESET);
if (deep) {
for (var i = 0; i < this._childRelations.length; i++) {
var r = this._childRelations[i];
r.detail.rejectChanges(deep);
}
}
//如果当前行为null，同时存在行数据，则设置当前行为首行
if (!this.currentRow && this.rows.length > -1) {
this.setCurrentRow(this.rows[0]);
}
};
/**
* 增加主从关系
* @param {DataSource} detail [description]
* @param {String} masterColunms [description]
* @param {String} detailColumns [description]
*/
DataSource.prototype.addRelation = function (detail, masterColunms, detailColumns) {
for (var i = 0; i < this._childRelations.length; i++) {
var r = this._childRelations[i];
if (r.detail === detail) {
return;
}
}
var relation = new DataRelation(this, detail, masterColunms, detailColumns);
if (detail._parentRelation != null)
throw '明细表已存在主表对象';
detail._parentRelation = relation;
this._childRelations.push(relation);
};
/**
* 获取第一个明细
* @return {[type]} [description]
*/
DataSource.prototype.getFirstDetail = function () {
if (this._childRelations.length > 0) {
return this._childRelations[0].detail;
}
return null;
};
/**
* 获取所有明细
* @param {String} [uiObjCode]
* @return {Array[DataSource]} [description]
*/
DataSource.prototype.getDetails = function (uiObjCode) {
var details = [];
for (var i = 0; i < this._childRelations.length; i++) {
var d = this._childRelations[i];
if (!uiObjCode || d.detail.uiObjCode == uiObjCode) {
details.push(d.detail);
}
}
return details;
};
DataSource.prototype.getMaster = function () {
if (this._parentRelation) {
return this._parentRelation.master;
}
return null;
};
DataSource.prototype.getDetailRelations = function () {
return this._childRelations;
};
DataSource.prototype.getParentRelation = function () {
return this._parentRelation;
};
DataSource.prototype.setSchemaData = function (schemaData) {
var rows = schemaData.rows;
var columns = schemaData.columns;
var totalRows = schemaData.totalRows;
//总行数
if (totalRows) {
this.setTotalRows(totalRows);
}
//列值
if (columns) {
for (var col in columns) {
var index = this.columns.names[col];
if (index == undefined) {
continue;
}
this.columns[index].paraValue = columns[col];
}
}
//数据
if (rows) {
this.loadData(rows);
}
};
DataSource.prototype.loadRows = function (rows) {
this.clear();
if (!rows || rows.length == 0) {
return;
}
this._isOpened = false;
var self = this;
try {
rows.forEach(rowData => {
var row = new DataRow(this, true);
for (var j = 0; j < self.columns.length; j++) {
var col = self.columns[j];
if (rowData.hasOwnProperty(col.fieldName)) {
row[col.fieldName] = rowData[col.fieldName];
}
if (rowData.hasOwnProperty(col.fieldName + '$')) {
row[col.fieldName + '$'] = rowData[col.fieldName + '$'];
}
}
self.addRow(row);
});
this.acceptChanges();
this.onCollectChanged(Global.Enums.CollectionChangedAction.RESET);
} finally {
this._isOpened = true;
}
this.moveTo(0);
}
DataSource.prototype.loadData = function (rows) {
if (!rows || !(rows instanceof Array)) return;
this.onBeforeDataSrcLoadData(rows);
this._isOpened = false;
try {
for (var i = 0; i < rows.length; i++) {
var rowData = toUpperKey(rows[i]);
var row = new DataRow(this, true);
for (var j = 0; j < this.columns.length; j++) {
var col = this.columns[j];
if (rowData.hasOwnProperty(col.fieldName.toUpperCase())) {
row[col.fieldName] = rowData[col.fieldName.toUpperCase()];
}
if (rowData.hasOwnProperty(col.fieldName.toUpperCase() + '$')) {
row[col.fieldName + '$'] = rowData[col.fieldName.toUpperCase() + '$'];
}
if (row[col.fieldName] && col.dataType === Global.Enums.DataType.DATETIME) {
row[col.fieldName] = new Date(Number(row[col.fieldName]))
}
}
this.addRow(row);
}
this.acceptChanges();
this._isOpened = true;
this.onCollectChanged(Global.Enums.CollectionChangedAction.RESET);
this.onAfterDataSrcLoadData(true);
} catch (e) {
this._isOpened = true;
this.onAfterDataSrcLoadData(false);
throw e;
}
this.setCurrentRow(this.rows[0]);
};
DataSource.prototype.sort = function (fieldName) {
this._isOpened = false;
try {
var isNumber = this.getColumn(fieldName).dataType === Global.Enums.DataType.NUMBER
this.rows.sort((r1, r2) => {
var a = r1[fieldName]
var b = r2[fieldName]
if (isNumber) {
return Number(a) - Number(b)
}
if (!a && !b) {
return 0
}
if (!a && b) {
return 1
}
if (a && !b) {
return -1
}
return a.localeCompare(b)
})
} finally {
this._isOpened = true
}
this.onCollectChanged(Global.Enums.CollectionChangedAction.RESET);
}
DataSource.prototype.resetData = function (data) {
this._isOpened = false;
try {
this._idSequence = {};
this.rows = data.rows;
this._originRows = data.origin;
this._deletedRows = data.deleted;
this.currentRow = this.rows[0] || null;
this.onCollectChanged(Global.Enums.CollectionChangedAction.RESET);
} catch (e) {
console.log(e);
}
this._isOpened = true;
};
DataSource.prototype.removeEmptyRow = function () {
var self = this;
//移除空行
for (var j = this.rows.length - 1; j > -1; j--) {
var row = this.rows[j];
if (row.isEmpty()) {
row.delete();
}
var details = self.getDetails();
for (var i = 0; i < details.length; i++) {
var d = details[i];
if (row[d.name]) {
self.removeDetailEmptyRow(row[d.name].rows);
}
};
};
};
DataSource.prototype.removeDetailEmptyRow = function (rows) {
for (var j = rows.length - 1; j > -1; j--) {
var row = rows[j];
if (row.isEmpty()) {
rows.splice(j, 1);
}
}
};
DataSource.prototype.validate = function (deep) {
var msgs = [];
//先移除空行，再校验
this.removeEmptyRow();
this.getChanges(function (row) {
if (row.dataRowState !== Global.Enums.DataRowState.DELETED) {
row.validate(function (err) {
msgs.push(err);
});
}
});
if (msgs.length > 0) {
Global.messager.err(toStrLines(msgs));
return false;
}
if (msgs.length == 0 && deep) {
for (var i = 0; i < this._childRelations.length; i++) {
var rel = this._childRelations[i];
//先移除空行，再校验
if (!rel.detail.validate(true)) {
return false;
}
//明细必填检查
if (this.getRequireDetail() && rel.detail.isEmpty()) {
Global.messager.err(Global.format(Global.MSG.DS_REQUIREDETAIL, rel.detail.uiObjName));
return false;
}
}
}
return true;
};
function acceptChanges(dataSrc, deep) {
dataSrc.acceptChanges();
if (deep) {
for (var i = 0; i < dataSrc._childRelations.length; i++) {
var rel = dataSrc._childRelations[i];
acceptChanges(rel.detail, true);
}
}
}
/**
* 设置保存扩展类，用于调用服务器的保存操作
* @param {[type]} className [description]
*/
DataSource.prototype.setServerBiz = function (className) {
this.serverBiz = className;
};
/**
* 获取包含结构信息的保存操作数据
* @return {Object} 数据
*/
DataSource.prototype.getSchemaData = function (args, cb) {
if (!args) {
args = {};
}
var self = this;
//结构
var table = {
funcCode: self.funcCode,
uiObjCode: this.uiObjCode,
serverBiz: this.serverBiz,
dataObjType: self.dataObjType,
pageSize: args.updateRow ? 0 : self._pageSize,
pageIndex: self._pagenum,
totalRows: self._totalRows,
queryParams: self.getQueryParams(args),
columnParams: self.getColumnParams(),
isMaster: self.isMaster,
detailRelation: [],
searchTableName: self._searchTableName,
rows: [],
state: self.state
};
if (args.deep) {
for (var i = 0; i < self._childRelations.length; i++) {
var r = self._childRelations[i];
if (r.detail._followMaster) {
table.detailRelation.push(r.getSchema({
deep: args.deep,
nodata: args.nodata
}));
}
}
}
//存储过程不需要数据
if (self.dataObjType == Global.Enums.DataObjType.STOREDPROC) {
args.nodata = true;
}
//数据
if (!args.nodata) {
if (args.onlyOne) {
var curRow = self.currentRow;
var rowData = curRow.getData();
table.rows.push(rowData);
} else {
self.getChanges(function (row) {
if (row.dataRowState == Global.Enums.DataRowState.DELETED ||
row.dataRowState == Global.Enums.DataRowState.MODIFIED ||
row.dataRowState == Global.Enums.DataRowState.ADDED) {
var _rowData = row.getData();
table.rows.push(_rowData);
}
var _prow = self.getParentRelaventRow(row);
_prow && (cb ? cb(_prow, args.oldSchema) : '');
});
}
if (self.isMaster && table.rows.length === 0) {
if (!self.currentRow) {
throw new Error('保存时，未指定主表当前行')
}
table.rows.push(self.currentRow.getData())
}
}
if (args.deleteCur) {
var __curRow = self.currentRow;
if (!__curRow) { throw new Error('delete row not found'); }
var __rowData = __curRow.getData();
__rowData.$state = Global.Enums.DataRowState.DELETED;
table.rows.push(__rowData);
}
return table;
};
DataSource.prototype.getParentRelaventRow = function (row) {
var self = this;
var _row = null;
var curMasterRow = null;
// 如果从表数据有改动,强制添加当前从表对应的主表行到保存数据中
if (self.isMaster === false && self.getMaster() !== null) {
var curMaster = self.getMaster();
var paRelation = self.getParentRelation();
for (var jj = 0; jj < curMaster.rows.length; jj++) {
curMasterRow = curMaster.rows[jj];
var filt = true;
for (var ii = 0; ii < paRelation.masterColunms.length; ii++) {
var curColumn = paRelation.masterColunms[ii];
// 添加对主从关联键只有一个键并且主从关联键名称不一致的情况的支持。
var detailColumn = paRelation.detailColumns[ii];
if (paRelation.masterColunms.length > 1) {
detailColumn = curColumn;
}
if (curMasterRow[curColumn] != row[detailColumn]) {
filt = false;
break;
}
}
if (filt) {
_row = curMasterRow.getData();
break;
}
}
}
return _row ? {
row: curMasterRow,
_row: _row
} : null;
};
/**
* 主动提交编辑状态
* @returns {boolean}
*/
DataSource.prototype.commitEdit = function() {
if (!this.onCommitEdit()) {
return false;
}
return true;
}
DataSource.prototype.save = function (callback, deep) {
var self = this;
if (!this.commitEdit()) {
saveCallBack(this, false, callback)
}
var allow = this.onBeforeDataSrcSave();
if (!allow) {
saveCallBack(this, false, callback)
return;
}
//检查业务逻辑是否通过
if (this.validate(deep) == false) {
saveCallBack(this, false, callback)
return;
}
//存储过程的保存需要处理入参
if (self.dataObjType == Global.Enums.DataObjType.STOREDPROC) {
self.onSetStoredProcParas();
}
var postData = {
beforeProc: '',
afterProc: '',
saveData: {},
serverBiz: self.serverBiz
};
postData.saveData[this.uiObjCode] = self.getSchemaData({
deep: deep,
onlyOne: self.onlySaveCurrent
});
if (Object.keys(postData.saveData).length == 0) {
saveCallBack(self, true, callback);
return;
}
if (self.beforeSaveProc && self.beforeSaveProc.isDataSource) {
postData.beforeProc = self.beforeSaveProc.uiObjCode;
postData.saveData[postData.beforeProc] = self.beforeSaveProc.getSchemaData({
nodata: true
});
}
if (self.beforeSaveProc && self.beforeSaveProc.isDataSource) {
postData.afterProc = self.beforeSaveProc.uiObjCode;
postData.saveData[postData.afterProc] = self.beforeSaveProc.getSchemaData({
nodata: true
});
}
Global.services.saveData(postData, function (isOk, data) {
if (isOk) {
var schemaData = data[self.uiObjCode];
self.setSchemaData(schemaData);
acceptChanges(self, deep);
if (self.isMaster) {
self.updateRow();
}
}
saveCallBack(self, isOk, callback);
});
};
function saveCallBack(ds, result, callback) {
if (callback) {
callback(result);
}
ds.onAfterDataSrcSave(result);
}
/**
* 删除当前行到服务器
* @return {[type]} [description]
*/
DataSource.prototype.delete = function (callback) {
if (this.currentRow) {
var self = this;
var postData = {
beforeProc: '',
afterProc: '',
saveData: {},
serverBiz: self.serverBiz
};
postData.saveData[self.uiObjCode] = self.getSchemaData({
deep: true,
onlyOne: self.onlySaveCurrent,
nodata: true,
deleteCur: true
});
if (self.beforeDeleteProc && self.beforeDeleteProc.isDataSource) {
postData.beforeProc = self.beforeDeleteProc.uiObjCode;
//self.beforeProc.getSaveSchemaData(false, postData.saveData);
postData.saveData[postData.beforeProc] = self.beforeDeleteProc.getSchemaData({
nodata: true
});
}
if (self.beforeDeleteProc && self.beforeDeleteProc.isDataSource) {
postData.afterProc = self.beforeDeleteProc.uiObjCode;
//self.afterProc.getSaveSchemaData(false, postData.saveData);
postData.saveData[postData.afterProc] = self.beforeDeleteProc.getSchemaData({
nodata: true
});
}
Global.services.saveData(postData, function (isOk, data) {
if (isOk) {
var row = self.currentRow;
self.deleteRow(row);
var clearChild = function (dataSrc) {
for (var i = 0; i < dataSrc._childRelations.length; i++) {
var r = dataSrc._childRelations[i];
r.detail.clear();
clearChild(r.detail);
}
}
clearChild(self);
self.acceptChanges();
if (!self.currentRow) {
self.moveToPrev();
}
}
if (callback) {
callback(isOk);
}
});
}
};
/**
* @param {DataSource} ds 数据源
* @param {DataRow} masterRow 主表行
* @param {DataRow} curRow 当前行
*/
DataSource.prototype.getQueryParams = function (args) {
var params = {},
ds = this;
if (args.updateRow) {
params.fixQuery = {};
for (var i = 0; i < ds.columns.length; i++) {
var col = ds.columns[i];
if (col.isPrimaryKey) {
params.fixQuery[col.fieldName] = args.updateRow[col.fieldName];
}
}
if (Object.keys(params.fixQuery).length === 0) {
throw new Error('主键未找到')
}
} else {
params = {
refQuery: ds.refQuery,
searchQuery: ds.searchQuery,
fixQuery: {},
defaultQuery: {
funcObjCode: ds.name,
funcCode: ds.funcCode
},
projectQuery: {},
treeQuery: ds.treeQuery,
userExtSqlQuery: ds.queryParamPlugin
};
_.extend(params.fixQuery, ds.fixQuery);
if (ds.linkQuery) {
params['linkQuery'] = ds.linkQuery;
ds.linkQuery = null;
}
if (ds.cautionQuery) {
params['cautionQuery'] = ds.cautionQuery;
ds.cautionQuery = null;
}
if (ds.defaultOrder && ds.defaultOrder.length > 0) {
var _order = {};
try {
var orderList = ds.defaultOrder.split(',');
orderList.forEach(function (item, index) {
var itemArray = item.split(' ');
if (!itemArray[1]) {
_order[itemArray[0]] = 0;
} else {
_order[itemArray[0]] = itemArray[1].toLowerCase() === 'desc' ? 1 : 0;
}
})
} catch (e) {
console.log(e);
}
params.order = _order;
}
if (args.masterRow) {
_.extend(params.fixQuery, ds._parentRelation.getParams(args.masterRow))
}
this.onGetQueryParams(params);
}
if (ds._parentRelation) {
var masterRow = ds._parentRelation.master.currentRow;
params.M = masterRow ? masterRow.getData() : {};
}
params.state = this.state
return params;
}
/**
* 获取列值传输对象，用于服务器处理存储过程入参
* @param {DataSource} ds
* @return {Object}
*/
DataSource.prototype.getColumnParams = function () {
var params = {},
ds = this;
if (ds.dataObjType == Global.Enums.DataObjType.STOREDPROC) {
for (var i = 0; i < ds.columns.length; i++) {
var col = ds.columns[i];
if (col.procParaType == Global.Enums.ProcParaType.IN || col.procParaType == Global.Enums.ProcParaType.INOUT) {
params[col.fieldName] = col.paraValue;
}
};
}
return params;
}
/**
* 刷新数据源数据
* @param {Function} callback 参数isOk，DataSource
* @return {undefined}
*/
DataSource.prototype.search = function (callback, args) {
var self = this;
args = args || {}
if (Global) {
if (!args || args.reset) {
self.setPagenum(0);
self.setTotalRows(-1);
}
if (!self.onBeforeSearch()) return;
if (self.dataObjType == Global.Enums.DataObjType.STOREDPROC) {
self.onSetStoredProcParas();
}
var postData = {
beforeProc: self.beforeSearchProc,
afterProc: self.afterSearchProc,
searchData: {},
serverBiz: self.serverBiz,
sync: args.sync || false
};
// 明细分页search条件支持
var schemaArgs = { nodata: true };
if (!self.isMaster && self._parentRelation) {
schemaArgs = {
masterRow: self._parentRelation.master.currentRow
}
}
postData.searchData[self.uiObjCode] = self.getSchemaData(schemaArgs);
Global.services.searchData(postData, function (isOk, result) {
if (isOk) {
//优先清除数据，保证数据的实时性
self.clear();
var schemaData = result[self.uiObjCode];
self.setSchemaData(schemaData);
acceptChanges(self);
}
if (callback) {
callback(isOk, self);
}
});
}
};
/**
* 更新某一行的数据
* @param {DataRow} [dr]
* @return
*/
DataSource.prototype.updateRow = function (dr) {
var self = this;
if (Global) {
if (self.dataObjType == Global.Enums.DataObjType.STOREDPROC) {
return;
}
if (!dr) {
dr = self.currentRow;
}
if (!dr) {
return;
}
if (dr.dataRowState !== Global.Enums.DataRowState.UNCHANGED) {
Global.showError("数据已修改，请先保存再更新");
}
var postData = {
beforeProc: null,
afterProc: null,
searchData: {},
sync: true
};
postData.searchData[self.uiObjCode] = self.getSchemaData({
updateRow: dr,
nodata: true
});
var isCurrentRow = dr == this.currentRow;
Global.services.searchData(postData, function (isOk, result) {
if (isOk) {
var schemaData = result[self.uiObjCode];
if (schemaData.rows && schemaData.rows.length === 1) {
dr.loadData(schemaData.rows[0]);
} else {
Global.showError(Global.MSG.UPDATEROW_ERR);
}
dr.acceptChanges();
if (isCurrentRow) {
self.onCurrentChanged(dr, dr);
}
return;
}
});
}
};
/**
* 根据主表行，刷新当前明细
* @param {[type]} dr [description]
* @param {Function} callback [description]
* @return {[type]} [description]
*/
DataSource.prototype.searchByMaster = function (dr, callback) {
var self = this;
self.clear();
if (!dr || dr.dataRowState == Global.Enums.DataRowState.ADDED) {
if (callback) {
callback(true, self);
}
return;
}
if (self._parentRelation === null || self._parentRelation.master != dr.dataSrc) {
throw 'searchByMaster:' + Global.MSG.SEARCH_MASTER_ROW_ERROR;
}
if (self.dataObjType == Global.Enums.DataObjType.STOREDPROC) {
Global.throwException(Global.MSG.SEARCH_ERROR_DETAIL, 'searchByMaster');
}
if (Global) {
var postData = {
beforeProc: self.beforeSearchProc,
afterProc: self.afterSearchProc,
searchData: {}
};
self.setPagenum(0);
postData.searchData[self.uiObjCode] = self.getSchemaData({
masterRow: dr
});
Global.services.searchData(postData, function (isOk, result) {
if (isOk) {
//优先清除数据，保证数据的实时性
self.clear();
var schemaData = result[self.uiObjCode];
self.setSchemaData(schemaData);
}
if (callback) {
callback(isOk, self);
}
});
}
};
/**
* 加载相关明细
* @param {Function} callback 回调
* @return {[type]} [description]
*/
DataSource.prototype.loadDetails = function (callback) {
var postData = {
beforeProc: null,
afterProc: null,
searchData: {}
};
var dr = this.currentRow;
_.extend(postData.searchData, this.getDetailsParams(dr, function (ds) {
ds.clear();
}));
if (postData.length == 0) {
if (callback) {
callback(true);
}
} else {
var self = this;
Global.services.searchData(postData, function (isOk, data) {
for (var j = 0; j < self._childRelations.length; j++) {
var d = self._childRelations[j];
if (isOk && data.hasOwnProperty(d.detail.uiObjCode)) {
var result = data[d.detail.uiObjCode];
d.detail.clear();
d.detail.setSchemaData(result);
acceptChanges(d.detail);
}
}
if (callback) {
callback(isOk, self);
}
});
}
};
/**
* 获取从表查询约束
* @param {当前行} dr 主表行
* @param {function} fn 每个明细的处理 fn(ds){}
* @return {array} 参数集合
*/
DataSource.prototype.getDetailsParams = function (dr, cb) {
var searchData = {};
for (var i = 0; i < this._childRelations.length; i++) {
var r = this._childRelations[i];
if (cb) {
cb(r.detail);
}
if (dr && dr.dataRowState !== Global.Enums.DataRowState.ADDED) {
searchData[r.detail.uiObjCode] = r.detail.getSchemaData({
masterRow: dr
});
}
}
return searchData;
};
/**
* 获取字符串字节长度
* @param str
* @returns {number}
*/
var getLength = function (str) {
if (str === null || str === undefined) return 0;
var realLength = 0;
for (var i = 0; i < str.length; i++) {
var charCode = str.charCodeAt(i);
if (charCode >= 0 && charCode <= 128)
realLength += 1;
else
realLength += 3;
}
return realLength;
};
function getScaleLength(val) {
if (!val) {
return 0;
}
var str = String(val)
var dotIndex = str.indexOf('.');
var len = str.length;
return dotIndex > 0 ? len - dotIndex - 1 : 0;
}
function getIntegerLength(val) {
if (!val) {
return 0;
}
var str = String(val)
var dotIndex = str.indexOf('.');
var len = str.length;
return dotIndex > 0 ? dotIndex : len;
}
/**
* 校验列值宽度
* @param dr
* @param dc
* @param value
* @returns {bool}
*/
var validateColumnWidth = function (dr, dc, value) {
if (dc.isCalc || (!value && value !== 0)) {
return true;
}
if (dc.dataType == Global.Enums.DataType.STRING || dc.dataType == Global.Enums.DataType.TEXT) {
var len = getLength(value);
if (len > dc.dataWidth) {
dr.setColumnError(dc, dc.dataSrc.onGetDataWidthErr(dr, dc, Global.format(Global.MSG.VALIDATE_LENGTH, dc.dispName, dc.dataWidth)));
return false;
}
}
if (dc.dataType == Global.Enums.DataType.NUMBER) {
var scale = getScaleLength(value);
var integer = getIntegerLength(value);
var realInteger = dc.dataWidth - dc.dataDec;
var realScale = dc.dataSrc.onGetPrecision(dr, dc);
realInteger = realInteger > 0 ? realInteger : 0;
if (scale > realScale || integer > realInteger) {
dr.setColumnError(dc, dc.dataSrc.onGetDataWidthErr(dr, dc, Global.format(Global.MSG.VALIDATE_LENGTH_NUM, dc.dispName, realInteger, realScale)));
return false;
}
}
return true;
};
/**
* 校验列类型
* @param dr
* @param dc
* @param value
* @returns {bool}
*/
var validateColumnType = function (dr, dc, value) {
if (dc.isCalc || (!value && value !== 0)) {
return true;
}
var bRet = false;
switch (dc.dataType.toString()) {
case Global.Enums.DataType.DATETIME:
bRet = !isNaN(Date.parse(value));
if (!bRet) {
var regDate = /^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)([ T][0-2]?[0-9]:[0-5]?[0-9]:[0-5]?[0-9])?$/;
var regTime = /[0-9]{2}:[0-9]{2}:[0-9]{2}/;
bRet = regDate.test(value) || regTime.test(value);
}
break;
default:
bRet = true;
}
if (!bRet) {
dr.setColumnError(dc, dc.dataSrc.onGetDataTypeErr(dr, dc, Global.format(Global.MSG.VALIDATE_TYPE, dc.dispName, value)));
}
return bRet;
};
var valiateColumnRule = function (dr, dc, value) {
if (!dc.setRule) return true;
var reg = new RegExp(dc.setRule);
if (!reg.test(value)) {
dr.setColumnError(dc, dc.dataSrc.onGetDataRuleErr(dr, dc, Global.format(Global.MSG.VAILIDATE_RULE, dc.dispName, value)));
}
};
var validateColumnStrictRef = function (dr, dc, value) {
if (dc.isTableRef() || dc.isEnumRef()) {
//获取参照内容
dc.loadRefData(dr, value, false, true);
if (value != dc.match && (value || value === 0)) {
//严格校验,只有表参照和枚举生效
if (dc.isStrictRef && !dc.getRefItem()) {
dr.setColumnError(dc,
dc.dataSrc.onGetDataStrictErr(dr, dc, Global.format(Global.MSG.VALIDTE_STRICTREF, dc.dispName, value)));
return false;
}
}
}
return true;
}
/**
* 校验列值，调用业务类
* @param {DataRow} dr [description]
* @param {DataColumn} dc [description]
* @param {Object} value [description]
* @return {bool} [description]
*/
DataSource.prototype.validateColumn = function (dr, dc, value, callback) {
//类型校验
if (!validateColumnType(dr, dc, value)) return false;
//长度校验
if (!validateColumnWidth(dr, dc, value)) return false;
//严格校验
if (!validateColumnStrictRef(dr, dc, value)) return false;
//自定义校验
return this.onDataColumnValidate(dr, dc, value);
};
/**
* 校验多选列值，调用业务类
* @param {DataRow} dr [description]
* @param {DataColumn} dc [description]
* @param {Object} value [description]
* @return {bool} [description]
*/
DataSource.prototype.validateQueryMultiColumn = function (dc, value, callback) {
//自定义校验
return this.onQueryDataColumnValidate(dr, dc, value);
};
/**
* 检查重复校验字段
* @param {Object} ds 数据源
* @param {Object} dr 行
* @return {Object} 两个属性valid和msg
*/
DataSource.prototype.checkMultiField = function (ds, dr) {
//检查行重复
if (ds.multiFields && ds.multiFields.length > 0) {
var cols = ds.multiFields.split(',');
//检查校验字段是否存在
for (var i = 0; i < cols.length; i++) {
if (!ds.getColumn(cols[i])) {
return {
valid: false,
msg: Global.MSG.MULTIFIELD_MISS
};
}
}
//获取行标识，用于辨别重复
var getTag = function (r) {
var tag = '';
for (var i = 0; i < cols.length; i++) {
var col = cols[i];
tag = tag + '_' + r[col];
}
return tag;
}
var curTag = getTag(dr);
for (var j = 0; j < ds.rows.length; j++) {
var row = ds.rows[j];
if (row === dr) {
continue;
} else {
var tag = getTag(row);
if (tag === curTag) {
var index = _.findIndex(row.dataSrc.rows, row) + 1;
var msg = "";
if (ds.isMaster === true) {
msg = ds.onGetMultiMsg(dr);
} else {
var cur = row.dataSrc.rows[index - 1];
var msg = ds.onGetMultiMsg(dr);
var cnt = 0;
//查询有多少个占位符
msg.replace(/\{(\w+)\}/g, function () {
cnt++;
});
//获得占位符字段，并进行替换
for (var n = 0; n < cnt; n++) {
var field = msg.substr(msg.indexOf('{') + 1, msg.indexOf('}') - (msg.indexOf('{') + 1));
msg = msg.replace('{' + field + '}', cur[field]);
}
//如果没有占位符 直接提示平台原始信息
if (cnt === 0)
msg = Global.MSG.LINE + index + ': ' + ds.onGetMultiMsg(dr);
}
return {
valid: false,
msg: msg
};
}
}
}
}
return {
valid: true,
msg: null
};
}
/**
* 校验行操作
* @param {DataRow} dr [description]
* @return {[type]} [description]
*/
DataSource.prototype.validateDataRow = function (dr, onerror) {
var self = this,
error = function (errmsg) {
if (onerror) {
onerror(errmsg);
}
},
ret;
// 处理更新字段并检查行必填
for (var k = 0; k < self.columns.length; k++) {
var col = self.columns[k];
self.onUpdateValue(dr, col);
if (col.isRequired && (!dr[col.fieldName] && dr[col.fieldName] !== 0)) {
dr.setColumnError(col.fieldName, col.dispName + Global.MSG.VALUE_REQUIRE, true);
}
}
//检查空行
if (dr.isEmpty()) {
setTimeout(function () {
dr.delete();
}, 120);
return false;
}
if (dr.hasError()) {
error(toStrLines([dr.getErrors()]));
return false;
}
//检查行重复
var result = this.checkMultiField(self, dr);
if (!result.valid && dr == this.currentRow) {
error(result.msg);
return false;
}
return self.onDataRowValidate(dr, error);
};
/**
* 获取默认值
* @param {[type]} dr [description]
* @param {[type]} col [description]
* @return {[type]} [description]
*/
DataSource.prototype.getDefaultValue = function (dr, col) {
if (typeof col === 'string') {
col = this.getColumn(col);
}
if (col) {
var relationValue = this._parentRelation ? this._parentRelation.getDetailValue(col) : null;
var dfValue = relationValue === null ? col.defaultValue : relationValue;
return this.onGetDefaultValue(dr, col, dfValue);
}
return null;
};
/**
* 获取列相关的参照内容
* @param {DataRow} row [description]
* @param {DataColumn} column [description]
* @param {Object} value [description]
* @param {Function} callback [description]
* @return {bool} 是否有数据
*/
DataSource.prototype.loadDefaultRefData = function (row, column, value, ignoreValue, isEdit) {
isEdit = isEdit ? !!isEdit : this.getEditable();
column.setRefData();
column.setRefItem();
if (column.refType == Global.Enums.RefType.ENUM) {
var result = Global.getEnumValue(column.refObj);
if (!result) {
Global.throwException(Global.MSG.NONE_ENUM, column.refObj);
}
if (isEdit && column.refEditWhere) {
var items = column.refEditWhere.split(',');
var enumValues = {};
for (var i = 0; i < items.length; i++) {
var item = items[i];
enumValues[item] = result[item];
}
result = enumValues;
}
result = this.onGetUserRefData(row, column, result);
if (result.hasOwnProperty(value)) {
column.setRefItem(result);
}
column.setRefData(result);
}
if (column.isTableRef()) {
//行不为空，表示进行严格校验，如果值为空或者为通配符，则跳出校验
if (!ignoreValue && !value && value !== 0) {
return;
}
if (!ignoreValue && value == column.match) {
var item = {};
this.columns.forEach(function (c) {
item[c.fieldName.toUpperCase()] = c.defaultValue;
});
item[column.fieldName.toUpperCase()] = column.match;
column.setRefItem(item, row);
column.setRefData([item]);
return;
}
//同步访问服务器，获取参照数据
var postData = {
funcCode: this.funcCode || '*',
searchData: {},
sync: true
};
postData.searchData[column.getRefObjCode()] = {
pageSize: 0,
pageIndex: 0,
totalRows: -1,
uiObjCode: column.getRefObjCode(),
queryParams: {
refQuery: column.getRefParam(row, value, isEdit, ignoreValue)
}
};
var result = Global.services.searchData(postData);
if (!result) {
Global.throwException(Global.MSG.NONE_REFDATA, column.refObj);
}
var schemaData = result[column.getRefObjCode()];
var refRows = schemaData ? schemaData.rows : [];
result = this.onGetUserRefData(row, column, refRows);
if (_.isArray(result) && result.length > 0) {
column.setRefItem(result[0], row);
}
column.setRefData(result);
}
};
DataSource.prototype.getNextId = function (dc) {
if (dc.dataType != Global.Enums.DataType.NUMBER) {
return;
}
if (this._idSequence.hasOwnProperty(dc.fieldName)) {
if (this.rows.length == 0) {
this._idSequence[dc.fieldName] = 0;
}
return ++this._idSequence[dc.fieldName];
} else {
var maxNum = 0;
for (var i = 0; i < this.rows.length; i++) {
var num = parseInt(this.rows[i][dc.fieldName]) || 0;
if (maxNum < num) {
maxNum = num;
}
}
this._idSequence[dc.fieldName] = maxNum + 1;
return maxNum + 1;
}
};
/**
* 重置NextId种子，Clear方法会默认执行该方法
* @param {DataColumn} [dc]
*/
DataSource.prototype.resetNextId = function (dc) {
if (dc) {
if (this._idSequence.hasOwnProperty(dc.fieldName)) {
delete this._idSequence[dc.fieldName];
}
} else {
this._idSequence = {};
}
};
DataSource.prototype.isEmpty = function () {
for (var i = 0; i < this.rows.length; i++) {
var row = this.rows[i];
if (!row.isEmpty()) {
return false;
}
}
return true;
};
/**
* 更新父数据
* @param col 明细列
*/
DataSource.prototype.updateParent = function (col) {
var parentRlt = this.getParentRelation();
if (parentRlt) {
parentRlt.aggregateDetail(col);
}
}
/****当前行操作-开始****/
/**
* 设置当前行，引起行变换事件
* @param {Object} row DataRow，也可以为数字，指行在当前数据源中的位置
*/
DataSource.prototype.setCurrentRow = function (row) {
if (this._isOpened) {
if (typeof row === 'number') {
row = this.rows[row];
}
var oldRow = this.currentRow;
this.currentRow = row === undefined ? null : row;
if (oldRow !== row) {
this.onCurrentChanged(row, oldRow);
}
}
};
/**
* 求列和
* @param {[type]} col [列]
* @param {[type]} start [开始位置]
* @param {[type]} end [终止位置]
* @return {[type]} [列值之和]
*/
DataSource.prototype.sumColValue = function (col, start, end) {
var sum = 0;
var i = null;
if (typeof col === 'string') {
col = this.getColumn(col);
}
if (col.isDataColumn && col.dataType == Global.Enums.DataType.NUMBER) {
for (i = start; i <= end; i++) {
if (this.rows.length > 0) {
if (!this.rows[i]) continue;
sum = BigNumber.add(sum, parseFloat(this.rows[i][col.fieldName]) || 0);
}
}
sum = sum.toFixed(parseInt(col.dispScale));
} else {
sum = '';
}
return sum;
}
/**
* 求平均值
* @param {[type]} col [列]
* @param {[type]} start [开始位置]
* @param {[type]} end [终止位置]
* @return {[type]} [列值之平均值]
*/
DataSource.prototype.averageColValue = function (col, start, end) {
var average = null;
var sum = null;
if (typeof col === 'string') {
col = this.getColumn(col);
}
if (col.isDataColumn && col.dataType == Global.Enums.DataType.NUMBER) {
sum = this.sumColValue(col, start, end);
if (sum === '') {
average = '';
} else {
average = (sum / (end - start + 1)).toFixed(parseInt(col.dispScale));
}
} else {
average = '';
}
return average;
}
/**
* 获取特定范围内列的最大值
* @param {[type]} col [列]
* @param {[type]} start [开始位置]
* @param {[type]} end [终止位置]
* @return {[type]} [列最大值]
*/
DataSource.prototype.getColMaxValue = function (col, start, end) {
var max = 0;
var i = null;
if (typeof col === 'string') {
col = this.getColumn(col);
}
if (col.isDataColumn && col.dataType == Global.Enums.DataType.NUMBER) {
for (i = start; i <= end; i++) {
if (!this.rows[i]) continue;
var _temp = parseFloat(this.rows[i][col.fieldName]) || 0;
max = max >= _temp ? max : _temp;
}
} else {
max = '';
}
return max;
}
/**
* 获取特定范围内列的最小值
* @param {[type]} col [列]
* @param {[type]} start [开始位置]
* @param {[type]} end [终止位置]
* @return {[type]} [列最小值]
*/
DataSource.prototype.getColMinValue = function (col, start, end) {
var min = 0;
var i = null;
if (typeof col === 'string') {
col = this.getColumn(col);
}
if (col.isDataColumn && col.dataType == Global.Enums.DataType.NUMBER) {
for (i = start; i <= end; i++) {
if (!this.rows[i]) continue;
var _temp = parseFloat(this.rows[i][col.fieldName]) || 0;
min = min <= _temp ? min : _temp;
}
} else {
min = '';
}
return min;
}
/**
* 移动到指定位置
* @param {Number} position 行位置
* @return {[type]} [description]
*/
DataSource.prototype.moveTo = function (position) {
if (this.dataView) {
this.dataView.moveTo(position);
} else {
var row = this.rows[position];
row = row == undefined ? null : row;
this.setCurrentRow(row);
}
};
/**
* 向下移动一行
* @return {[type]} [description]
*/
DataSource.prototype.moveToNext = function () {
var position = this.rows.indexOf(this.currentRow);
position++;
if (position >= this.rows.length) {
position = this.rows.length;
}
if (position < 0) {
position = 0;
}
this.moveTo(position);
};
/**
* 向上移动一行
* @return {[type]} [description]
*/
DataSource.prototype.moveToPrev = function () {
var position = this.rows.indexOf(this.currentRow);
position--;
this.moveTo(position < 0 ? 0 : position);
};
/**
* 移动到首行
* @return {[type]} [description]
*/
DataSource.prototype.moveToFirst = function () {
this.moveTo(0);
};
/**
* 移动到最后一行
* @return {[type]} [description]
*/
DataSource.prototype.moveToLast = function () {
this.moveTo(this.rows.length - 1);
};
DataSource.prototype.beforeAddFirstRow = function () {
if (this.rows.length > 0) {
return true
}
return this.onBeforeAddFirstRow()
}
/****当前行操作-结束****/
/****事件-开始****/
DataSource.prototype.onBeforeAddFirstRow = function () {
var args = {
cancel: false
}
this.fire('onBeforeAddFirstRow', args)
return !args.cancel
}
/**
* 获取某行某列的精度
* @param dr
* @param dc
*/
DataSource.prototype.onGetPrecision = function (dr, dc) {
var args = {
row: dr,
col: dc,
precision: dc.dataDec
};
this.fire('onGetPrecision', args);
return args.precision;
}
/**
* 数据发生变化事件
* @param {[type]} row [description]
* @param {[type]} col [description]
* @return {[type]} [description]
*/
DataSource.prototype.onFieldChanged = function (row, col) {
var args = {
row: row,
col: col,
valid: true,
err: ''
}
this.fire('onFieldChanged', args);
return args;
};
DataSource.prototype.onBeforeSearch = function () {
var params = {
isCancel: false
}
this.fire('onBeforeSearch', params);
return !params.isCancel;
};
DataSource.prototype.onGetQueryParams = function (params) {
this.fire('onGetQueryParams', params);
return params;
};
DataSource.prototype.onCollectChanged = function (type, dr) {
this.fire('onCollectChanged', {
action: type,
row: dr
});
};
DataSource.prototype.onGetColumnFormatter = function (dc, fmt) {
var args = {
col: dc,
formatter: fmt
};
this.fire('onGetColumnFormatter', args);
return args.formatter;
};
DataSource.prototype.onUserRefDlg = function (args) {
this.fire('onUserRefDlg', args);
};
DataSource.prototype.onUserMultiRefDlg = function (args) {
this.fire('onUserMultiRefDlg', args);
};
DataSource.prototype.onGetUserRefColumnWhere = function (dr, dc, isEdit) {
var args = {
row: dr,
col: dc,
isEdit: isEdit,
where: {}
};
this.fire('onGetUserRefColumnWhere', args);
return args.where;
};
DataSource.prototype.onGetRowFormatter = function (dr, dc) {
var args = {
row: dr,
col: dc,
formatter: null
};
this.fire('onGetRowFormatter', args);
return args.formatter
};
/**
* 获取类型错误信息
* @param {DataRow} dr
* @param {DataColumn} dc
* @returns {*}
*/
DataSource.prototype.onGetDataTypeErr = function (dr, dc, err) {
var args = {
row: dr,
col: dc,
err: err
};
this.fire('onGetDataTypeErr', args);
return args.err;
};
DataSource.prototype.onGetDataWidthErr = function (dr, dc, err) {
var args = {
row: dr,
col: dc,
err: err
};
this.fire('onGetDataWidthErr', args);
return args.err;
};
DataSource.prototype.onGetDataRuleErr = function (dr, dc, err) {
var args = {
row: dr,
col: dc,
err: err
};
this.fire('onGetDataRuleErr', args);
return args.err;
};
/**
* 属性改变通知
* @param {string} property 属性名称
* @return {undefined}
*/
DataSource.prototype.onPropertyChanged = function (property) {
this.fire('onPropertyChanged', {
propertyName: property
});
};
DataSource.prototype.onGetMultiMsg = function (dr) {
var args = {
row: dr,
err: this.multiMsg
};
this.fire('onGetMultiMsg', args);
return args.err;
};
DataSource.prototype.onGetDataStrictErr = function (dr, dc, err) {
var args = {
row: dr,
col: dc,
err: err
};
this.fire('onGetDataStrictErr', args);
return args.err;
};
DataSource.prototype.getFieldReadOnly = function (dr, dc) {
var args = {
row: dr,
col: dc,
readOnly: dc.getReadOnly()
};
if (!args.readOnly &&
this._parentRelation &&
this._parentRelation.detailColumns.indexOf(dc.fieldName) > -1) {
args.readOnly = true;
}
if (!args.readOnly &&
this.isMaster &&
dc.isPrimaryKey &&
dr.dataRowState != Global.Enums.DataRowState.ADDED) {
args.readOnly = true;
}
this.fire('onGetFieldReadOnly', args);
return args.readOnly;
};
DataSource.prototype.onGetContextMenus = function (source) {
var args = {
source: source,
items: []
};
this.fire('onGetContextMenus', args);
return args.items;
};
DataSource.prototype.onGetPrintVariables = function () {
var args = {
variables: {}
};
this.fire('onGetPrintVariables', args);
return args.variables;
};
DataSource.prototype.onBeforeDataSrcLoadData = function (data) {
this.fire('onBeforeDataSrcLoadData', {
data: data
});
};
DataSource.prototype.onAfterDataSrcLoadData = function (result) {
this.fire('onAfterDataSrcLoadData', {
result: result
});
};
DataSource.prototype.onSetStoredProcParas = function () {
this.fire('onSetStoredProcParas', {});
};
/**
* 删除行前询问
* @param dr 删除行
* @return ｛bool}
*/
DataSource.prototype.onRowDeleting = function (dr, needConfirm, fn) {
var self = this;
var del = function () {
//删除前询问
var args = {
dataSrc: this,
row: dr,
isCancel: false
};
self.fire('onRowDeleting', args);
if (!args.isCancel) {
fn();
}
};
if (needConfirm) {
Global.messager.confirm(Global.MSG.DELETE_CONFIRM, function (r) {
if (r) del();
});
} else {
del();
}
};
/**
* 删除行后处理
* @param dr 删除行
* @return
*/
DataSource.prototype.onRowDeleted = function (dr) {
//删除后通知
this.fire('onRowDeleted', {
dataSrc: this,
row: dr
});
};
DataSource.prototype.onUpdateValue = function (dr, col) {
this.fire('onUpdateValue', {
row: dr,
col: col
})
};
DataSource.prototype.onDataColumnValidate = function (dr, dc, value) {
//自定义校验
var args = {
row: dr,
col: dc,
value: value,
isCancel: false
};
this.fire('onDataColumnValidate', args);
return !args.isCancel;
};
// 多选查询自定义校验
DataSource.prototype.onQueryDataColumnValidate = function (dc, value) {
//自定义校验
var args = {
col: dc,
value: value,
isCancel: false
};
this.fire('onQueryDataColumnValidate', args);
return !args.isCancel;
};
DataSource.prototype.onDataRowValidate = function (dr, error) {
//业务类校验
var args = {
row: dr,
isCancel: false,
msg: ''
};
this.fire('onDataRowValidate', args);
if (args.isCancel) {
error(args.msg);
}
return !args.isCancel;
};
DataSource.prototype.onGetUserRefData = function (row, column, data) {
var args = {
row: row,
col: column,
result: data
};
this.fire('onGetUserRefData', args);
return args.result;
};
DataSource.prototype.onRowAdded = function (dr) {
this.fire('onRowAdded', {
dataSrc: this,
row: dr
});
};
DataSource.prototype.onRowRemoved = function (dr) {
var args = {
dataSrc: this,
row: dr
};
this.fire('onRowRemoved', args);
};
DataSource.prototype.onCommitEdit = function() {
var args = {
isCancel: false
};
this.fire('commitEdit', args);
return !args.isCancel;
}
DataSource.prototype.onBeforeDataSrcSave = function () {
//保存前操作
var args = {
isCancel: false
};
this.fire('onBeforeDataSrcSave', args);
return !args.isCancel;
};
//提交所有的行并移除空行
DataSource.prototype.commitAndRemoveEmptyRow = function () {
var args = {
isCancel: false
};
this.fire('onBeforeDataSrcSave', args);
if (args.isCancel) {
return false;
}
var details = this.getDetails();
for (var i = 0; i < details.length; i++) {
args.isCancel = false;
details[i].fire('onBeforeDataSrcSave', args);
if (args.isCancel) {
return false;
}
}
return true;
};
DataSource.prototype.onAfterDataSrcSave = function (result) {
this.fire('onAfterDataSrcSave', {
result: result
});
};
DataSource.prototype.onCleared = function () {
this.fire('onCleared');
};
DataSource.prototype.onGetDefaultValue = function (dr, col, dfValue) {
var args = {
row: dr,
col: col,
value: dfValue
};
this.fire('onGetDefaultValue', args);
return args.value;
};
DataSource.prototype.onCurrentChanged = function (row, oldRow) {
var args = {
dataSrc: this,
oldRow: oldRow,
newRow: row
};
this.fire('onCurrentChanged', args);
};
DataSource.prototype.onValueChanged = function (dr, dc) {
var args = {
row: dr,
col: dc
};
this.fire('onValueChanged', args);
};
/****事件-结束****/
win.DataSource = DataSource;
})(window);
Reference in new issue View Git Blame Copy Permalink