// 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 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));
}