// myTbl插件
|
// 定义容器中表格
|
;(function($, window, document, undefined) {
|
/**
|
* @description 表格插件的定义
|
* @param jquery ele jquery选择器选中元素
|
* @param object options 插件的配置项
|
*/
|
var MyTbl = function(ele, options) {
|
this.ele = ele.eq(0);
|
this.opts = options;
|
this.init();
|
};
|
|
MyTbl.prototype = {
|
init: function() {
|
this.regData(); // 验证数据格式
|
this.ele.find('.no-data').remove(); // 清除无数据图标
|
this.ele.addClass('tbl-container');
|
this.ele.find('.tbl-body').fullContainer();
|
},
|
create: function() {
|
var opts = this.formatOpts();
|
|
// 根据数据生成表格元素
|
var table = $('<table></table>');
|
var thead = $('<thead></thead>');
|
var tr = $('<tr></tr>');
|
|
for(var i=0; i<opts.thead.length; i++) {
|
var td = $('<td>'+opts.thead[i]+'</td>');
|
tr.append(td);
|
}
|
|
thead.append(tr);
|
table.append(thead);
|
|
var tbody = $('<tbody></tbody>');
|
for(var i=0; i<opts.tbody.length; i++) {
|
var tr = $('<tr></tr>');
|
for(var k=0; k<opts.tbody[i].length; k++) {
|
var td = $('<td>'+opts.tbody[i][k]+'</td>');
|
tr.append(td);
|
}
|
tr.data().attr = opts.attr[i];
|
|
// 是否全部选中
|
if(opts.isAllActive) {
|
tr.addClass('active');
|
}
|
|
tbody.append(tr);
|
}
|
|
table.append(tbody);
|
|
this.ele.find('.tbl-body').text("");
|
|
this.ele.find('.tbl-body').append(table);
|
this.ele.find('.tbl-header').html(this.ele.find('.tbl-body').html());
|
if(this.opts.tbody.length == 0 && this.opts.noData) {
|
this.ele.append(this.noData());
|
}
|
|
this.resize();
|
var scrollLeft = this.ele.find('.tbl-body').scrollLeft();
|
this.ele.find('.tbl-body').siblings('.tbl-header').find('table').css('left', -scrollLeft+'px');
|
|
this.ele.find('.tbl-body').scroll(function() {
|
var scrollLeft = $(this).scrollLeft();
|
$(this).siblings('.tbl-header').find('table').css('left', -scrollLeft+'px');
|
});
|
},
|
|
// 添加一行数据
|
add: function() {
|
var isOne = true;
|
|
// 判断为二维数组
|
if(typeof this.opts.add[0] == 'object') {
|
isOne = false;
|
}
|
|
// 根据isOne的值执行
|
if(isOne) {
|
this.opts.tbody.push(this.opts.add);
|
this.opts.add = [];
|
}else {
|
for(var i=0; i<this.opts.add.length; i++) {
|
this.opts.tbody.push(this.opts.add[i]);
|
}
|
}
|
|
|
this.create();
|
},
|
// 格式化数据
|
formatOpts: function() {
|
// 将配置项的数据存储到当前元素的
|
var opts = $.extend(true, {}, this.opts);
|
|
// 计算表格的行数
|
opts.rows = opts.tbody.length;
|
|
// 根据表格行数向attr中添加默认对象
|
for(var i=0; i<opts.rows; i++) {
|
var tmp = {
|
lists: i
|
};
|
if(typeof opts.attr[i] != 'object') {
|
opts.attr[i] = $.extend(true, {}, tmp);
|
}else {
|
opts.attr[i] = $.extend(true, {}, opts.attr[i],tmp);
|
}
|
|
}
|
|
this.ele.data().options = opts;
|
|
var rsData = this.getRsData();
|
var rs = $.extend({}, opts, rsData);
|
return rs;
|
},
|
noData: function() {
|
var noData = $('<div class="no-data not-select"><img src="pages/images/nodata.png"></div>');
|
return noData;
|
},
|
resize: function() {
|
var tblWidth = this.ele.find('.tbl-body table').width();
|
this.ele.find('.tbl-header').children('table').width(tblWidth);
|
var tbl = this;
|
},
|
regData: function() { // 格式化表格的状态数组
|
var opts = this.opts;
|
var thead = opts.thead;
|
var status = opts.status;
|
// 遍历thead数据对status的数据进行校验和补齐
|
for(var i=0;i<this.opts.thead.length; i++) {
|
// status[i]没有被定义就用1补齐
|
if(status[i] == undefined) {
|
status[i] = 1;
|
}else {
|
// status[i]的值不是0或1就用1替换
|
if(status[i] != 0 && status[i] != 1) {
|
status[i] = 1;
|
}
|
}
|
}
|
},
|
getRsData:function() { // 根据状态数组修改并返回最终的数据
|
var rs = {
|
thead:[],
|
tbody:[],
|
};
|
|
var opts = this.opts;
|
var thead = opts.thead;
|
var tbody = opts.tbody;
|
var status = opts.status;
|
//console.info(status);
|
// 遍历status的值获取最终的thead数据
|
for(var i=0; i<status.length; i++) {
|
if(status[i] == 1) {
|
// 设置头部数据
|
rs.thead.push(thead[i]);
|
}
|
}
|
|
// 遍历tbody的值根据status值生成最终的tbody
|
for(var i=0; i<tbody.length; i++) {
|
var tmp = [];
|
for(var k=0; k<tbody[i].length; k++) {
|
if(status[k] == 1) {
|
tmp.push(tbody[i][k]);
|
}
|
}
|
rs.tbody.push(tmp);
|
}
|
//console.info(rs);
|
return rs;
|
}
|
};
|
|
// 向jquery中添加表格插件
|
$.fn.myTbl = function(options) {
|
var defaults = {
|
thead: [],
|
tbody: [],
|
attr:[],
|
rows:0,
|
status: [],
|
noData: false,
|
isAllActive: false,
|
event: 'create'
|
};
|
options.ele = this;
|
|
|
// 判断当前传递参数的类型
|
if(options !=undefined ) {
|
if(typeof options == 'string' || options.constructor.name == "Array") {
|
console.log('error options typeof!!!');
|
return this;
|
}
|
}
|
|
var opts = $.extend(true, {}, defaults, options || {});
|
var tbl = new MyTbl(this, opts);
|
|
if(tbl[opts.event]) {
|
tbl[opts.event]();
|
}else {
|
console.log('no '+opts.event+' event');
|
}
|
|
return this;
|
}
|
})(jQuery, window, document);
|
|
//当前容器充满父容器
|
;(function($, window, document) {
|
$.mainChild = [];
|
$.fn.fullContainer = function() {
|
var container = this.parent(); // 父节点
|
var siblings = this.siblings(); // 兄弟节点
|
var cHt = container.height(); // 父节点的高度
|
var sHt = 0; // 兄弟节点的高度总和
|
siblings.each(function(i) {
|
if(!$(this).hasClass('not-select')) {
|
sHt += $(this).outerHeight(true);
|
}
|
});
|
this.height(cHt-sHt);
|
this.addClass('main-child');
|
if(container.hasClass('tbl-container')) {
|
var tblWidth = container.children('.tbl-body').children('table').width();
|
container.children('.tbl-header').children('table').width(tblWidth);
|
}
|
|
// 没有参数传进来就将当前元素添加到$.mainChild中
|
if(arguments.length == 0) {
|
$.mainChild.push(this);
|
}
|
|
return this;
|
};
|
$.resizeMainChild = function() {
|
for(var i=0;i<$.mainChild.length; i++) {
|
$.mainChild[i].fullContainer('resize'); // 不触发插入mainChild的操作
|
}
|
}
|
|
|
// window的窗口大小改变就触发插件fullContainer
|
$(window).resize(function() {
|
$.resizeMainChild();
|
|
setTimeout(function() {
|
$.resizeMainChild();
|
}, 100);
|
});
|
})(jQuery, window, document, undefined);
|
|
// 带表格的页面
|
;(function($, window, document, gl) {
|
gl.namespace('tblPage')
|
//页面表格的配置项
|
var tblOpts = {
|
thead:[], // 表格头部信息
|
tbody:[], // 表格
|
attr: [], // 表格行重要的信息
|
add: [], // 是否添加
|
status:[] // 表格列显示状态
|
};
|
|
gl.tblPage.tblOpts = tblOpts;
|
})(jQuery, window, document, GLOBAL, undefined);
|
|
//存储不同设备的状态信息
|
;(function($, window, document, gl, undefined) {
|
// 61850设备
|
gl.namespace('DEV61850');
|
|
gl.DEV61850.workstates = ["在线浮充","预充电","核容测试","停电放电","内阻测试","K1/D1测试"]; // 设备工作状态
|
gl.DEV61850.alarmstates = ["继电器K1告警","通讯告警","设备过温告警","二极管D1告警"]; // 告警状态
|
gl.DEV61850.stopreasons = [
|
'设备掉电','手动终止', '放电时间到', '放电容量到', '单体电压下限到', '单体温度上限到', '组端电压下限到',
|
'市电中断', '单体模块通信异常', '存储数据满', '机内温度异常', '放电电流异常', '后台通信中断', '内部程序异常',
|
'电源电压高','协议转通信异常','其他'
|
]; // 核容停止原因
|
|
// BTS设备
|
gl.namespace('BTS9100');
|
gl.BTS9100.workstates = ['在线监测','放电测试','充电测试','内阻测试','未知', '放电测试（应急续航）', '放电测试（核容测试）']; // 设备工作状态
|
gl.BTS9100.alarmstates = [
|
'无','暂停','放电测试','放电等待','限流充电','直流充电','充电等待','测试时间到',
|
'测试容量到','单体下限到','组端下限到','市电异常','存储卡不足','负载温度高','电流异常','远程通信坏',
|
'负载通信坏','选择通信坏','载模块放电过功率停止','内部程序异常停止','市电恢复停止升压放电','充电过程中市电中断','合路器放电功能组端电压下限','温度上限到','未知'
|
];
|
/*gl.BTS9100.alarmstates = [
|
'无','暂停','放电测试','放电等待','限流充电','直流充电','充电等待','测试时间到',
|
'测试容量到','单体下限到','组端下限到','市电异常','存储卡不足','负载温度高','电流异常','远程通信坏',
|
'负载通信坏','选择通信坏','负载电流坏','内存申请坏','未知'
|
];*/
|
|
// LD9设备
|
gl.namespace('LD9');
|
gl.LD9.workstates = ['在线监测','核容测试','测试状态状态暂停','单节测试']; // 设备工作状态
|
gl.LD9.stopreasons = ['无','手动停止','单体下限到','充电完成停止','测试完成停止','远程停止','在线电压低'];
|
|
// 4016设备
|
gl.namespace('LD6');
|
gl.LD6.workstates = ['充电测试', '放电测试']; // 设备工作状态
|
gl.LD6.stopreasons = ['无','手动停止','核容测试时间到','核容测试组端下限到','核容测试单体下限到','核容测试容量低于阀值','应急供电组端下限到'
|
, '应急供电单体下限到', '市电恢复停止应急供电', '停止自动应急供电', '无法启动核容测试', '模块故障', '电池开路故障'];
|
})(jQuery, window, document, GLOBAL);
|
|
// 基站信息
|
;(function($, window, document, gl, undefined) {
|
// 基站异常类型
|
gl.namespace('BaseStation.Abnormal');
|
//1:基站停电 2:基站续航 3:基站发电 4:基站开门 5:基站掉站 6:基站温度上限 7:基站温度下限 8:基站湿度上限 9:基站湿度下限
|
var abnormal = ['全部（异常）', '基站停电', '基站续航', '基站发电', '基站开门', '基站掉站', '基站温度上限', '基站温度下限', '基站湿度上限', '基站湿度下限'];
|
gl.BaseStation.Abnormal = abnormal;
|
|
|
// 根据下标获取基站异常类型的文本值
|
function getAbnormalTxt(num) {
|
var rs = abnormal[num];
|
if(rs == undefined) {
|
alert('基站异常类型'+num+'不存在');
|
rs = abnormal[0];
|
}
|
return rs;
|
}
|
// 将函数绑定到GLOBAL.BaseStation
|
gl.BaseStation.getAbnormalTxt = getAbnormalTxt;
|
|
|
|
})(jQuery, window, document, GLOBAL);
|
|
//页面中计时器的使用
|
;(function($, gl) {
|
gl.namespace('Timer');
|
var timerList = [];
|
|
|
// 定义计时器类
|
var Timer = function(opts) {
|
this.timer = '';
|
this.opts = {};
|
this._setOpts(opts);
|
timerList.push(this);
|
};
|
|
var _prop = Timer.prototype;
|
|
_prop._setOpts = function(opts) {
|
var defaults = {
|
fun: '',
|
params: [],
|
times: 1000
|
};
|
|
this.opts = $.extend({}, defaults, opts);
|
};
|
|
// 启动计时器
|
_prop.start = function() {
|
var opts = this.opts;
|
this.stop();
|
|
opts.fun.apply({}, opts.params);
|
this.timer = setInterval(function() {
|
opts.fun.apply({}, opts.params);
|
}, opts.times);
|
};
|
|
// 停止计时器
|
_prop.stop = function() {
|
clearInterval(this.timer);
|
};
|
|
// 停止所有通过Timer类声明的计时器
|
function stop() {
|
for(var i=0; i<timerList.length; i++) {
|
timerList[i].stop();
|
}
|
}
|
|
// 启动所有通过Timer类声明的计时器
|
function start() {
|
for(var i=0; i<timerList.length; i++) {
|
timerList[i].start();
|
}
|
}
|
|
// 启动/关闭所有所有通过Timer类声明的计时器
|
gl.Timer.startAll = start;
|
gl.Timer.stopAll = stop;
|
// 将计数器添加到全局中
|
gl.Timer.timer = Timer;
|
})(jQuery, GLOBAL);
|
|
//定义设备类型
|
;(function($, window, document, gl, undefined) {
|
// 定义设备类型equipType命名空间
|
gl.namespace('equipType');
|
|
var type = {
|
LD9: /^40190/,
|
equip61850: /^61850/,
|
BTS:/^(9100)|(9600)|(9616)/,
|
BTSSreen: /^9611/,
|
equip4016:/^4016/
|
};
|
|
// 绑定到命名空间equipType中
|
gl.equipType.type = type;
|
|
// 验证类型
|
function regType(id, pattern) {
|
var rs = true;
|
rs = pattern.test(id);
|
return rs;
|
}
|
|
// 绑定到命名空间equipType中
|
gl.equipType.regType = regType;
|
})(jQuery, window, document, GLOBAL);
|
|
//设置充放电参数的名称
|
;(function($, window, document, gl, undefined) {
|
// CMD的命名空间
|
gl.namespace('CMD');
|
|
// CMD下BTS的命名空间
|
gl.namespace('CMD.BTS');
|
gl.CMD.BTS.startDischarge = 37; //容量测试
|
gl.CMD.BTS.startRESTest = 50; //内阻测试
|
gl.CMD.BTS.getDischargeParm = 41; //获取放电参数
|
gl.CMD.BTS.setDischargeParm = 40; //设置放电参数
|
gl.CMD.BTS.start = 81; //启动测试
|
gl.CMD.BTS.stop = 83; //停止测试
|
|
// CMD下的61850命名空间
|
gl.namespace('CMD.e61850');
|
gl.CMD.e61850.startDischarge = 37; //启动核容测试
|
gl.CMD.e61850.startRESTest = 50; //启动内阻测试
|
|
gl.CMD.e61850.start = 81; //启动测试
|
gl.CMD.e61850.stop = 83; //停止测试
|
gl.CMD.e61850.setDischargeParm = 40; //设置参数
|
gl.CMD.e61850.getDischargeParm = 41; //获取参数
|
|
//CMD下sys
|
gl.namespace('CMD.sys');
|
gl.CMD.sys.restart = 0x10;
|
gl.CMD.sys.set = 0x81;
|
gl.CMD.sys.get = 0x80;
|
|
//CMD下gprs
|
gl.namespace('CMD.gprs');
|
gl.CMD.gprs.param = 145;
|
gl.CMD.gprs.signal = "CSQ";
|
gl.CMD.gprs.threadinfo = 0x17;
|
|
// CMD下batt
|
gl.namespace('CMD.batt');
|
gl.CMD.batt.get = 0x36; // 获取电池参数
|
gl.CMD.batt.set = 0x37; // 设置电池参数
|
})(jQuery, window, document, GLOBAL);
|
|
// 问题类型
|
;(function($, window, document, gl, undefined) {
|
|
|
})(jQuery, window, document, GLOBAL);
|
|
// 地图信息
|
;(function($, window, document, gl, undefined) {
|
// 定义BMap的命名空间
|
gl.namespace('BMap');
|
// 地图可视区域定义
|
var mapViewArea = [
|
{name: '中国',area:'中国', left: {lng:71.3822, lat:0.6212}, right: {lng: 139.526,lat:54.3093}},
|
{name: '中国-广西',area: '广西省' ,left: {lng:104.45675, lat:20.8744}, right: {lng: 112.068,lat:26.391}}
|
];
|
|
// 将变量mapView绑定到GLOBAL.BMap下
|
gl.BMap.mapViewArea = mapViewArea;
|
|
})(jQuery, window, document, GLOBAL);
|
|
// 文本框数据的验证
|
;(function($, window, document, gl, undefined) {
|
// 定义testVal的命名空间
|
gl.namespace('testVal');
|
// 验证数据
|
function check(ele, ptn, callback) {
|
var val = ele.val();
|
var isGood = regVal(val, ptn);
|
setStyle(ele, isGood, ptn, callback);
|
}
|
|
// 将数据绑定到GLOBAL.testVal下
|
gl.testVal.check = check;
|
|
// 检测数据的有效性
|
function regVal(val, ptn) {
|
var flag = true;
|
var _val = val;
|
|
// 检验数据格式是否有效
|
if(!ptn.pattern.test(_val)) {
|
flag = false;
|
}
|
|
// 检验数据是否在取值区间(前提是数据格式正确且有区间)
|
if(flag && ptn.regVal) {
|
// val值不在取值范围
|
if(val<ptn.min || val>ptn.max) {
|
flag = false;
|
}
|
}
|
|
return flag;
|
}
|
|
// 设置文本框的样式
|
function setStyle(ele, isGood, ptn, callback) {
|
if(isGood) {
|
ele.next('i').removeClass('error-data');
|
ele.myTooltip('hide');
|
ele.removeClass('error-data');
|
}else {
|
ele.next('i').addClass('error-data');
|
ele.myTooltip({
|
position: ptn.position,
|
thing: 'show',
|
update: ptn.update,
|
content: '<span style="color:#FF0000">'+ptn.msg+'</span>'
|
});
|
ele.addClass('error-data');
|
}
|
// 是否回调函数
|
//console.log(callback);
|
if(isFunction(callback)) {
|
callback();
|
}
|
}
|
})(jQuery, window, document, GLOBAL);
|
|
// 导出报表
|
;(function($, window, document, gl, undefined) {
|
// 定义testVal的命名空间
|
gl.namespace('Table');
|
var ExpExcel = function() {
|
this.thead = ''; // 表格的头部
|
this.tbody = ''; // 表格的内容
|
this.normal = 1; // 是否为通用的导出
|
this.dataBreak = ''; // 数据分割符
|
this.pageNames = ''; // 工作簿名称
|
this.pageBreak = ''; // 工作簿分隔符
|
this.form = '';
|
this.form = this.initForm();
|
};
|
var prop = ExpExcel.prototype;
|
|
// 初始化
|
prop._init = function(obj) {
|
var defaults = {
|
thead: [],
|
tbody: [],
|
normal: 1,
|
dataBreak: '&',
|
pageNames: ['数据表格'],
|
pageBreak: '$'
|
};
|
|
// 合并对象
|
var opts = $.extend({}, defaults, obj | {});
|
|
this._setThead(obj.thead, opts.pageBreak, opts.dataBreak);
|
this._setTbody(obj.tbody, opts.pageBreak, opts.dataBreak);
|
this._setPageNames(opts.pageNames, opts.pageBreak);
|
|
this.dataBreak = opts.dataBreak;
|
this.pageBreak = opts.pageBreak;
|
this.normal = opts.normal;
|
|
this.form = this.initForm();
|
this._setForm();
|
};
|
|
// 设置页面中的元素
|
prop._setForm = function() {
|
var ele = $('#exp_container');
|
// 创建容器
|
if(ele.length == 0) {
|
$('body').append($('<div id="exp_container"></div>'));
|
}
|
ele = $('#exp_container');
|
console.log(ele.length);
|
// 更新内容
|
ele.text('');
|
|
var form = $('<form id="exp_excel" action="ExportTable.servlet" method="post"></form>');
|
|
var thead = $('<input type="hidden" id="exp_thead" name="exp_thead" value=""/>');
|
var tbody = $('<input type="hidden" id="exp_tbody" name="exp_tbody" value=""/>');
|
var normal = $('<input type="hidden" id="exp_normal" name="exp_normal" value=""/>');
|
var dataBreak = $('<input type="hidden" id="exp_data_break" name="exp_data_break" value=""/>');
|
var pageNames = $('<input type="hidden" id="exp_page_names" name="exp_page_names" value=""/>');
|
var pageBreak = $('<input type="hidden" id="exp_page_break" name="exp_page_break" value=""/>');
|
|
thead.val(this.thead);
|
tbody.val(this.tbody);
|
normal.val(this.normal);
|
dataBreak.val(this.dataBreak);
|
pageNames.val(this.pageNames);
|
pageBreak.val(this.pageBreak);
|
|
form.append(thead);
|
form.append(tbody);
|
form.append(normal);
|
form.append(dataBreak);
|
form.append(pageNames);
|
form.append(pageBreak);
|
|
ele.append(form);
|
this.form = form;
|
};
|
|
// 设置表格头部的值
|
prop._setThead = function(thead, pageBreak, dataBreak) {
|
var arr = [];
|
// 数据分割
|
for(var i=0; i<thead.length; i++) {
|
var _arr = thead[i].join(dataBreak);
|
arr.push(_arr)
|
}
|
// 工作簿分割
|
var str = arr.join(pageBreak);
|
this.thead = str;
|
};
|
|
// 设置表格内容
|
prop._setTbody = function(tbody, pageBreak, dataBreak) {
|
var arr = [];
|
// 数据分割
|
for(var i=0; i<tbody.length; i++) {
|
var _arr = tbody[i].join(dataBreak);
|
arr.push(_arr)
|
}
|
// 工作簿分割
|
var str = arr.join(pageBreak);
|
this.tbody = str;
|
};
|
|
// 设置工作簿内容
|
prop._setPageNames = function(pageNames, pageBreak) {
|
var str = pageNames.join(pageBreak);
|
this.pageNames = str;
|
};
|
|
// 初始化form
|
prop.initForm = function() {
|
this.form = '12345';
|
};
|
|
// 导出表格
|
prop.xls = function(obj) {
|
|
this._init(obj); // 初始化内容
|
// 导出内容
|
if(this.form == '12345') {
|
alert('没有检测到form表单')
|
}else {
|
this.form.submit();
|
}
|
};
|
|
|
var expExcel = new ExpExcel();
|
//console.log(expExcel);
|
// 绑定导出数据对象
|
GLOBAL.Table.expExcel = expExcel;
|
|
|
//构造导出表格对象
|
function createTableData(tOptions){
|
var thead_arr = new Array(); //表头数据数组
|
var thody_arr = new Array(); //表格数据数组
|
var proname_arr = new Array(); //属性名数组
|
//console.info(tOptions);
|
if(tOptions != undefined){
|
//构造表头数组
|
for(var i = 0;i< tOptions.cols.length;i++){
|
var _th = tOptions.cols[i];
|
for(var k=0;k<_th.length;k++){
|
if(_th[k].field != undefined){
|
proname_arr.push(_th[k].field);
|
thead_arr.push(_th[k].title);
|
}
|
}
|
}
|
//构造表格内部数据数组
|
for(var j = 0;j < tOptions.data.length;j++){
|
var _data = tOptions.data[j];
|
for(var k=0;k<proname_arr.length;k++){
|
thody_arr.push(_data[proname_arr[k]]);
|
}
|
}
|
}
|
return {
|
thead: [thead_arr],
|
tbody:[thody_arr]
|
};
|
}
|
|
// 绑定导出数据对象
|
GLOBAL.Table.cTblData = createTableData;
|
})(jQuery, window, document, GLOBAL);
|
|
// 设置value和text对象的遍历和获取
|
;(function($, window, document, gl, undefined){
|
// 定义alarm的命名空间
|
gl.namespace('alarm');
|
// 定义类GetTxtByVal来存储含value,text的对象数组的数据
|
var GetTxtByVal = function(data) {
|
this.data=data;
|
};
|
|
// 定义原型方法
|
GetTxtByVal.prototype={
|
/**
|
* 更具val的值获取对应的文本值
|
* @param val 需要查询的键值
|
* @returns 如果为获取返回未知,否则返回对应的文本
|
*/
|
getTxt:function(val) {
|
var data = this.data;
|
var result = "未知";
|
// 遍历data的值
|
for(var i=0; i<data.length; i++) {
|
var _data = data[i];
|
if(val == _data.value) {
|
result = _data.text;
|
}
|
}
|
return result;
|
},
|
/**
|
* 获取所有的资源
|
* @returns 返回所用的资源
|
*/
|
getData: function() {
|
return this.data;
|
},
|
/**
|
* 获取数据中所有text属性的值
|
* @returns 返回数据中的所有的text属性的值
|
*/
|
getAllTxt:function() {
|
var result = [];
|
var data = this.data;
|
for(var i=0; i<data.length;i++) {
|
var _data = data[i];
|
result.push(_data.text);
|
}
|
return result;
|
}
|
};
|
|
// 电池告警(名称和ID)
|
var eleAlarmType = [
|
{text:"在线电压告警", value: "119001"},
|
{text:"组端电压告警", value: "119002"},
|
{text:"充电电流告警", value: "119003"},
|
{text:"放电电流告警", value: "119004"},
|
{text:"单体电压告警", value: "119005"},
|
{text:"单体温度告警", value: "119006"},
|
{text:"单体内阻告警", value: "119007"},
|
{text:"单体连接条告警", value: "119008"},
|
{text:"放电单体电压告警", value: "119009"},
|
{text:"容量告警告警", value: "119010"},
|
{text:"容量更换告警", value: "119011"},
|
];
|
|
// 设置告警(名称和ID)
|
var equipeAlarmType = [
|
{text:"通讯故障", value: "119020"},
|
{text:"继电器告警", value: "618501"},
|
{text:"通讯告警", value: "618502"},
|
{text:"设备过温告警", value: "618503"},
|
{text:"二极管D1告警", value: "618504"},
|
{text:"设备高温告警", value: "119028"},
|
{text:"设备SD卡故障", value: "119032"},
|
{text:"采集线告警", value: "119033"},
|
];
|
|
// 机房问题
|
var homeQues = [
|
{text: "电池问题", value:"0"},
|
{text: "电源问题", value:"1"},
|
{text: "空调问题", value:"2"},
|
{text: "漏水问题", value:"3"},
|
{text: "BTS设备问题", value:"4"},
|
{text: "GPRS模块问题", value:"5"},
|
{text: "施工安装问题", value:"6"},
|
{text: "铁锂电池问题", value:"7"},
|
{text: "其他问题", value:"8"},
|
];
|
// 电池告警
|
var eleAlarmTypeObj = new GetTxtByVal(eleAlarmType);
|
gl.alarm.ele = eleAlarmTypeObj;
|
|
// 设备告警
|
var equipeAlarmTypeObj = new GetTxtByVal(equipeAlarmType);
|
gl.alarm.equipe = equipeAlarmTypeObj;
|
|
// 机房问题
|
var homeQuesObj = new GetTxtByVal(homeQues);
|
gl.alarm.home = homeQuesObj;
|
|
// HomeQues的命名空间(记录机房问题)
|
gl.namespace('HomeQues');
|
var lists = homeQuesObj.getAllTxt();
|
|
// 将questions绑定到HomeQues下
|
gl.HomeQues.lists = lists;
|
|
// 获取option列表
|
function getOptions(bool) {
|
var options = '';
|
// 是否添加全部选项
|
if(bool) {
|
options += '<option value="-1">全部</option>';
|
}
|
// 遍历lists返回所有的option
|
for(var i=0; i<lists.length; i++) {
|
options += '<option value="'+i+'">'+lists[i]+'</option>';
|
}
|
return options;
|
}
|
|
// 将getOptions绑定到HomeQues下
|
gl.HomeQues.getOptions = getOptions;
|
|
// 获取故障类型layuiBtn
|
function getLayuiBtn(num) {
|
var txt = lists[num];
|
return '<a href="javascript:;" class="layui-btn layui-btn-xs">'+txt+'</a>';
|
}
|
|
// 将getLayuiBtn绑定到HomeQues下
|
gl.HomeQues.getLayuiBtn = getLayuiBtn;
|
|
})(jQuery, window, document, GLOBAL);
|
|
// 生成阿里图标的元素
|
function create_ali_font(cla, color, data) {
|
var i = $('<i class="icon iconfont"></i>');
|
i.addClass(cla);
|
i.css({
|
'color': color
|
});
|
Object.keys(data).forEach(function(key) {
|
var attr = 'data-'+key
|
i.attr(attr, data[key]);
|
});
|
// 获取字符串
|
var outerHTML = i[0].outerHTML;
|
return outerHTML;
|
}
|
|
//生成阿里图标的元素
|
function create_fa_font(cla, color, data) {
|
var i = $('<i class="fa"></i>');
|
i.addClass(cla);
|
i.css({
|
'color': color
|
});
|
Object.keys(data).forEach(function(key) {
|
var attr = 'data-'+key
|
i.attr(attr, data[key]);
|
});
|
// 获取字符串
|
var outerHTML = i[0].outerHTML;
|
return outerHTML;
|
}
|
|
// 生成跳转的链接
|
function skipUrl(page, province, city, county, home,battid,monnum) {
|
var str = page+'?';
|
if(province){
|
str += '&province='+province;
|
}
|
if(city){
|
str +='&city='+city;
|
}
|
if(county){
|
str += '&county='+county;
|
}
|
if(home){
|
str += '&home='+home;
|
}
|
if(battid){
|
str += '&battid='+battid;
|
}
|
if(monnum){
|
str += '&monnum='+monnum;
|
}
|
//var str = page+'?province='+province+'&city='+city+'&county='+county+'&home='+home;
|
return str;
|
}
|
|
// 生成跳转的链接
|
function skipURL (param) {
|
// page, province, city, county, home,battid,monnum
|
if (!param.page) {
|
console.log('参数错误');
|
return "PARAM_ERROR";
|
}
|
var str = Object.keys(param).length > 1 ? param.page + '?' : param.page;
|
var paramKeys = Object.keys(param);
|
paramKeys.splice(paramKeys.indexOf('page'), 1);
|
paramKeys.forEach(function (c, i, a) {
|
if (i == 0) {
|
str += c + "=" + encodeURIComponent(param[c]);
|
} else {
|
str += "&" + c + "=" + encodeURIComponent(param[c]);
|
}
|
});
|
// console.log('url :', str);
|
return str;
|
}
|
|
// 检测用户是否有权限
|
function checkUserPermit(permits, name) {
|
var rs = false;
|
// 遍历permits
|
for(var i=0; i<permits.length; i++) {
|
var _permit = permits[i];
|
if(_permit.permit_item_name == name && _permit.permit_item_value==1) {
|
rs = true;
|
break;
|
}
|
}
|
return rs;
|
}
|
|
//给GPRS发送指定的命令，获取AT返回值
|
function searchStationSignal(param,callback){
|
$.ajax({
|
type:"post",
|
url: "Bts_gprs_stateAction_action_update?t="+(new Date().getTime()),
|
async:true,
|
dataType:'json',
|
data:'json='+JSON.stringify(param),
|
success: function(data){
|
var model = eval('('+data.result+')');
|
if(callback && typeof callback == 'function'){
|
callback(model);
|
}
|
},error:function(e){
|
var model = {
|
code:0,
|
data:e,
|
msg:'通信失败'
|
};
|
if(callback && typeof callback == 'function'){
|
callback(model);
|
}
|
}
|
});
|
}
|
|
// 浮点型数据相减
|
function floatSub(a, b) {
|
var c, d, e;
|
try {
|
c = a.toString().split(".")[1].length;
|
} catch (f) {
|
c = 0;
|
}
|
try {
|
d = b.toString().split(".")[1].length;
|
} catch (f) {
|
d = 0;
|
}
|
return e = Math.pow(10, Math.max(c, d)), (mul(a, e) - mul(b, e)) / e;
|
}
|
|
// 浮点型数据相加
|
function floatAdd(a, b) {
|
var c, d, e;
|
try {
|
c = a.toString().split(".")[1].length;
|
} catch (f) {
|
c = 0;
|
}
|
try {
|
d = b.toString().split(".")[1].length;
|
} catch (f) {
|
d = 0;
|
}
|
return e = Math.pow(10, Math.max(c, d)), (mul(a, e) + mul(b, e)) / e;
|
}
|
|
function mul(a, b) {
|
var c = 0,
|
d = a.toString(),
|
e = b.toString();
|
try {
|
c += d.split(".")[1].length;
|
} catch (f) {}
|
try {
|
c += e.split(".")[1].length;
|
} catch (f) {}
|
return Number(d.replace(".", "")) * Number(e.replace(".", "")) / Math.pow(10, c);
|
}
|
|
function div(a, b) {
|
var c, d, e = 0,
|
f = 0;
|
try {
|
e = a.toString().split(".")[1].length;
|
} catch (g) {}
|
try {
|
f = b.toString().split(".")[1].length;
|
} catch (g) {}
|
return c = Number(a.toString().replace(".", "")), d = Number(b.toString().replace(".", "")), mul(c / d, Math.pow(10, f - e));
|
}
|
|
// 页面加载进度条
|
function ProgressLoad(ele, element) {
|
this.ele = ele;
|
this.element = element;
|
}
|
ProgressLoad.prototype.show = function() {
|
this.update(0);
|
this.ele.show();
|
};
|
ProgressLoad.prototype.hide = function() {
|
this.ele.hide();
|
};
|
ProgressLoad.prototype.update = function(percent){
|
var _self = this;
|
var progressTextEle = this.ele.find('.layui-progress-text');
|
var progressVal = progressText =percent+"%";
|
if(percent>=100) {
|
progressText="加载完成";
|
setTimeout(function() {
|
_self.hide();
|
}, 1500);
|
}
|
this.element.progress('load-progress', progressVal)
|
progressTextEle.text(progressText);
|
};
|
|
// 对象的排序
|
function SortObj() {
|
this.type = "";
|
this.data = [];
|
};
|
// 升序
|
SortObj.prototype._asc = function(data, attr) {
|
var attrs = attr.split('.');
|
for(var i=0; i<data.length-1; i++) {
|
for(var k=0; k<data.length -1-i; k++) {
|
var val1 = this._getVal(data[k], attrs);
|
var val2 = this._getVal(data[k+1], attrs);
|
if(val1>val2) {
|
var temp = data[k];
|
data[k] = data[k+1];
|
data[k+1] = temp;
|
}
|
}
|
}
|
return data;
|
};
|
|
// 降序
|
SortObj.prototype._desc = function(data, attr) {
|
var attrs = attr.split('.');
|
for(var i=0; i<data.length-1; i++) {
|
for(var k=0; k<data.length -1-i; k++) {
|
var val1 = this._getVal(data[k], attrs);
|
var val2 = this._getVal(data[k+1], attrs);
|
if(val1<val2) {
|
var temp = data[k+1];
|
data[k+1] = data[k];
|
data[k] = temp;
|
}
|
}
|
}
|
return data;
|
};
|
|
// 获取要排序的值
|
SortObj.prototype._getVal = function(data, attrs) {
|
var _self = this;
|
var result = data[attrs[0]];
|
for(var i=1; i<attrs.length; i++) {
|
var attr = attrs[i];
|
if(result && typeof result[attr] == 'object') {
|
result = result[attr]
|
}else if(result){
|
result = result[attr];
|
}
|
}
|
//console.log(result);
|
return result;
|
};
|
|
// 设置排序类型
|
SortObj.prototype.setType = function(str) {
|
var type = "";
|
switch(str) {
|
case 'asc':
|
type = str;
|
break;
|
case 'desc':
|
type = 'desc';
|
break;
|
default:
|
type='';
|
break;
|
}
|
this.type = type;
|
};
|
|
//对象排序
|
SortObj.prototype.sort = function(data, attr, type) {
|
var result = data;
|
this.type = type?type:this.type;
|
switch(this.type) {
|
case 'asc':
|
result = this._asc(data, attr);
|
break;
|
case 'desc':
|
result = this._desc(data, attr);
|
break;
|
default:
|
result = data;
|
break;
|
}
|
this.data = data;
|
return data;
|
}
|
