yctb-SpringBoot/web/js/comm/fw/ajax.js

/**通用ajax服务的定义对象
 * services可以是单个服务对象，也可以是service服务数组
 * 具体服务的定义请参考appendServices成员函数
 */
function Service(services){
	this.services=[];
	this.shareParameters={};
	/**添加共享参数，在这里统一设置共享参数
	 */
	this.addShareParameters=function(shareParameters){
		this.shareParameters=shareParameters;
		return this;
	};
	/**
	 * 批量调用一般服务
	 * 入参可以是一个调用服务的数组或者单个调用服务
	 * 每个调用服务有下面的属性
	 * serviceId 服务Id，不可为空
	 * method 服务方法名，不可为空
	 * parameters 服务参数，必须是object，object的属性名代表参数名，属性值代表参数值。
	 * transform：结果集的转换规则（返回结果集合List<Map<String,Object>>时才会用到）：null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写 
	 * shareResults 共享服务的返回结果，默认不共享false，如果后续服务需要使用到结果里面的参数，
	 *   那么就需要明确指定。该参数可以是 boolean,array或者object，为true时表示全部共享；
	 *   数组可以指定返回值中需要共享的值的名，这样返回值的键值对应关系共享；
	 *   object可以额外指定共享名的别名，当要求返回值以新的字段名共享、
	 *   或者一个以多个新别名共享时就需要用到这种类型，object的属性名表示结果集中需要共享的字段名，
	 *   属性值表示新的字段名；
	 *   参数共享处理列表结果集时，整个结果集的数据存放在别名为空串的特殊key上。如果本业务没有返回结果，那么参数共享无效。
	 * useShare 使用共享参数标志，定义方式与shareResults一样，意义正好想对应。该参数指明如果从共享参数中获取要的值。
	 * shareNotNull 校验共享参数是否为空，作为useShare的附属属性。
	 *   有时希望如果获取到的共享参数是空的，那么不继续执行，那么可以在这里指定哪些一定不能为空。
	 *   目前只允许三种取值，null,true和别名数组，null表示不校验，true表示全校验，别名数组表示只校验指定的值（别名是指useShare中新的别名，并非共享池里面的共享别名）。
	 */
	this.appendServices=function(services){
		if(!services){
			return this;
		}
		//默认按批量形式添加服务，如果是单个，那么用数组包装
		var tmp_services=services;
		if(!$.isArray(tmp_services)){
			tmp_services = [tmp_services];
		}
		//每个service必须有serviceId，method
		for(var index=0 ;index< tmp_services.length;index++){
			//检查必录项
			if(!tmp_services[index].serviceId||!tmp_services[index].method){
				_FW.oFtl.fnAlert('服务定义的serviceId和method不可为空');
				return this;
			}
			//检查可选项
			if(tmp_services[index].parameters){
				if(typeof tmp_services[index].parameters !='object'
					||jQuery.isArray(tmp_services[index].parameters)){
					_FW.oFtl.fnAlert('服务定义的参数必须是map！');
					return;
				}
			}
			//如果指定了transform，那么值只能是规定的
			if(tmp_services[index].transform){
				if('FIRSTROW'!=tmp_services[index].transform.toUpperCase()
						&&'BREAKDOWN'!=tmp_services[index].transform.toUpperCase()){
					_FW.oFtl.fnAlert('transform属性不正确');
					return this;
				}
			}
			//shareResults
			//转换shareResults，统一转换成map，或者boolean
			shareResults = tmp_services[index].shareResults;
			if(shareResults){
				if(typeof shareResults =='boolean'){
					if(!shareResults){
						shareResults =null;
					}
				}else if(jQuery.isArray(shareResults)){
					//转化为map
					shareResults={};
					$.each(tmp_services[index].shareResults,function(indexInArray, valueOfElement){
						shareResults[valueOfElement]=valueOfElement;
					});
					tmp_services[index].shareResults =shareResults;
				}
			}
			//useShare
			useShare = tmp_services[index].useShare;
			if(useShare){
				if(typeof useShare =='boolean'){
					if(!useShare){
						tmp_services[index].useShare =null;
					}
				}else if(jQuery.isArray(useShare)){
					//转化为map
					useShare={};
					$.each(tmp_services[index].useShare,function(indexInArray, valueOfElement){
						useShare[valueOfElement]=valueOfElement;
					});
					tmp_services[index].useShare =useShare;
				}
			}
			//shareNotNull，只允许true和字符串数组
			shareNotNull = tmp_services[index].shareNotNull;
			if(shareNotNull){
				if(typeof shareNotNull !=='boolean' && !jQuery.isArray(shareNotNull)){
					_FW.oFtl.fnAlert('参数[shareNotNull]的取值必须是true或者字符串数组！');
					return this;
				}else if(shareNotNull ===false){
					tmp_services[index].shareNotNull = null;
				}
			}
		}
		this.services=this.services.concat(tmp_services);
		return this;
	};
	/**定义添加直接调用存储过程的服务
	 * 可以批量添加存储过程。每个存储过程服务的有以下属性：
	 * procName、parameters、shareResults、useShare，
	 * 其中procName指明存储过程的名称，其他的请参考appendServices；parameters中的参数名不能是procName
	 * 批量添加存储过程时，用数组存储各个存储过程作为参数传入即可。
	 * ...
	 */
	this.appendProc=function(procedures){
		if(!procedures){
			return this;
		}
		//默认按批量形式添加服务，如果是单个，那么用数组包装
		tmp_procedures=procedures;
		if(!$.isArray(tmp_procedures)){
			tmp_procedures = [tmp_procedures];
		}
		//遍历，一个一个的处理
		procedure_services =[];
		for (var index=0;index< tmp_procedures.length;index++){
			//必须有configId属性
			procedure = tmp_procedures[index];
			if(!procedure.procName){
				_FW.oFtl.fnAlert('存储过程服务必须指定procName属性');
				return this;
			}
			procedure = $.extend(true,{},procedure,
					{serviceId:'directJdbcService',method:'savePointProcedure'
						,parameters:{'':procedure.procName}});
			//去掉存储过程名称
			delete procedure.procName;
			//添加到服务列表
			procedure_services.push(procedure);
		}
		return this.appendServices(procedure_services);
	};
	/**定义添加调用预定义查询语句的服务
	 * 可以批量添加查询语句。每个查询服务的包括以下属性：
	 * configId、transform、indices，parameters、shareResults、useShare。
	 * configId是Mapper.xml中的配置ID(注意写上空间名)
	 * parameters是传递给configId的参数
	 * transform：结果集的转换规则：null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写
	 * ，该参数要求传入字符串数组类型，元素值指明参数Map中的一个参数名。
	 * 其它属性将作为查询语句的备用参数。其他的请参考appendServices；
	 * 批量添加查询服务时，用数组存储各个查询服务作为参数传入即可。
	 * ...
	 */
	this.appendQuery=function(querys){
		if(!querys){
			return this;
		}
		//默认按批量形式添加服务，如果是单个，那么用数组包装
		tmp_querys=querys;
		if(!$.isArray(tmp_querys)){
			tmp_querys = [tmp_querys];
		}
		//遍历，一个一个的处理
		query_services = [];
		for (var index=0;index<tmp_querys.length;index++){
			//必须有configId属性
			var query = tmp_querys[index];
			if(!query.configId){
				_FW.oFtl.fnAlert('查询服务必须指定configId属性');
				return this;
			}
			//参数索引放入参数串中
			query = $.extend(true,{},query,
					{serviceId:'commService',method:'query'
						,parameters:{'_commDo':query.configId}});
			
			//去掉存储过程名称，和参数索引
			delete query.configId;
			
			//添加到服务列表
			query_services.push(query);
		}
		return this.appendServices(query_services);
	};
	/**定义触发ajax的事件
	 * message:本次ajax请求的名称，可选。
	 * success:处理成功后触发的函数，原型是function(data)。
	 * error:处理是否时触发的函数，原型是function(XMLHttpRequest, textStatus, errorThrown);
	 * async：同步或是异步，同步为false、异步是true
	 */
	this.sentAjax=function(message,success,error,async){
		var that=this;
		if(this.services.length==0){
			_FW.oFtl.fnAlert('请至少添加一个服务');
			return;
		}
		var t_async = true;
		var t_message = message;
		var t_success = success;
		var t_error = error;
		if(jQuery.isFunction(message)){
			t_message = '正在请求服务，请稍候...';
			t_success =message;
			t_error = success;
		}else if (typeof message != 'string'){
			_FW.oFtl.fnAlert('入参错误，请检查程序！');
			return ;
		}
		if(async!=null&&typeof async=='boolean'){
			if(!async){
				t_async = false;
			}
		}
		var thisrequest={};
		 $.ajax({
			url:contextPath+'/ajaxAdapter.do'
			,data:{parameters:JSON.stringify(this.services),shareArguments:JSON.stringify(this.shareParameters)}
			,dataType :'json'
			,cache:false
			,async:t_async
			,contentType: "application/x-www-form-urlencoded; charset=utf-8"
			,type:'post'
			,error:function (request, textStatus, errorThrown) {
				if(!t_error){
					_FW.oFtl.fnAlert('数据请求错误！');	
				}else{
					t_error(request, textStatus, errorThrown);
				}
				}
			,success:function (data, textStatus) {
				if(data!=null && data[headtoken]!=null){
					token=data[headtoken];//更新全局变量token标志
				}
				
				//校验业务处理是否正确执行
				if("1"!=data.FHZ){//出错了，弹出错误提醒
					if ("loginTimeout" == data.FHZ) {
						if(window.confirm(data.MSG||'')){
							window.top.location.href=_selfUrl;
						}
					} else if("CSRF" == data.FHZ){
						showMsg(data.MSG||'',3);
						return;
					} else {
						if(t_error){
							t_error(data.MSG||'', 'serviceErr', data.MSG);
						}else{
							_FW.oFtl.fnAlert(data.MSG||'');
						}
					}
				}else if(!t_success){
				}else{
					t_success(data.RTN);
				}
			}
			,beforeSend:function(XMLHttpRequest ){
				var cToken = $.cookie(headtoken) || token;XMLHttpRequest.setRequestHeader(headtoken,cToken);
				$.data(thisrequest,'msg',showMsg(t_message,-1));
				//createProgressBar();
			}
			,complete:function( ){
				hideMsg($.data(thisrequest,'msg'));
			}
		 });
	};
	//添加参数
	if(services){
		this.appendServices(services);
	}
	/**
	 * 将JSON序列化为一个字符串，
	 * 相对于JSON.stringify，{}中的键值对会按照key升序顺序输出。
	 */
	function stringify(o){
		var toString = Object.prototype.toString;
		var s = "";
		if(null === o){
			return "null";
		}else if(undefined === o){
			return "undefined";
		}else if("[object Function]" === toString.call(o)){
			return "\"[object Function]\"";
		}else if("[object Object]" === toString.call(o)){
			s += "{";
			var arr = [];
			for(var key in o){
				arr.push(key);
			}
			arr.sort();
			for(var i in arr){
				var key = arr[i];
				s += "\"" + key + "\":" + stringify(o[key]) + ",";
			}
			s = s.substring(0,s.length-1);
			s += "}";
		}else if("[object Array]" === toString.call(o)){
			s += "[";
			for(var i in o){
				s += stringify(o[i]);
				if(i != o.length-1){
					s += ",";
				}
			}
			s += "]";
		}else if("[object Number]" === toString.call(o)){
			if(isFinite(o)){
				return "" + o;
			}else if(isNaN(o)){
				return "NaN";
			}else if(Infinity === o){
				return "Infinity";
			}
		}else if("[object String]" === toString.call(o)){
			return "\"" + o + "\"";
		}else if("[object Boolean]" === toString.call(o)){
			return true === o?"true":"false"
		}else if("[object RegExp]" === toString.call(o)){
			return "/"+ o.source +"/" 
				+ (o.global?"g":"")  
				+ (o.ignoreCase?"i":"")
				+ (o.multiline?"m":"");
		}else{
			return "\"" + toString.call(o) + "\"";
		}
		return s;
	}
}
/**
* 在页面的左上角显示错误消息
* @param msg 消息内容
* @param timeout 秒为单位,0或者负数表示不自动隐藏
* @author 吴英德
**/
var framework_message_layer;
var clearIntervalID;
function showMsg(msg,delay){

	var recurrectLocation=function(){
		if(framework_message_layer==null)
				{clearInterval(clearIntervalID);return;}
			var posX,posY;
	    if (window.innerHeight) {
	        posX = window.pageXOffset;
	        posY = window.pageYOffset;
	    }
	    else if (document.documentElement && document.documentElement.scrollTop) {
	        posX = document.documentElement.scrollLeft;
	        posY = document.documentElement.scrollTop;
	    }
	    else if (document.body) {
	        posX = document.body.scrollLeft;
	        posY = document.body.scrollTop;
	    }
		framework_message_layer.style.top=String(posY+10)+'px';
		framework_message_layer.style.right=String(posX+10)+'px';
	};
	if(framework_message_layer == null){
		framework_message_layer=document.createElement('div');
		framework_message_layer.className='err_message_blank_board';
		document.body.appendChild(framework_message_layer);
		clearIntervalID=window.setInterval(recurrectLocation,100);
		recurrectLocation();
	}
	var my_div = document.createElement('div');
	my_div.className='err_message';
	//Element.extend(my_div);
	my_div.innerHTML=msg;
	 //增加判断：已经存在的信息，则不再重复提示
	 if ($(".err_message:contains("+msg+")",document.body).length == 0) {    
		 framework_message_layer.appendChild(my_div);
    	 recurrectLocation();
     }    
	if(delay>0){
		setTimeout(function(){
			jQuery(my_div).remove();
			if(jQuery(framework_message_layer).is(':empty')){
				jQuery(framework_message_layer).remove();
				window.clearInterval(clearIntervalID);
				framework_message_layer=null;
			}
		},delay*1000);
	}else{
		return my_div;
	}
}

/**隐藏右上角对应的消息
 * @param object 某消息对象，来自showMsg的返回值
 */
function hideMsg(object){
	jQuery(object).remove();
}