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

/**
 * @author herong 框架-Ajax基类
 */
var CFWAjax = _FW.fCreateClass();
/**
 * Ajax API
 */
CFWAjax.prototype = {
		
		
		/**
		 * 初始化
		 * */
		fInitialize : function(options) {
			
		},

	/**
	 * ajax调用Service 
	 * 通过ajax直接请求调用中间层业务处理类(Service)
	 * @param sServiceName
	 *            (必需) 业务Service类名和方法名,格式: 首字母小写的类名.方法名(方法入参类型必须为IDTO)
	 * @param mParams
	 *            入参数json对象,key要求大写
	 * @param sMessage
	 *            提示信息
	 * @param fnSuccessCallback
	 *            (必需) 成功回调方法，方法格式：function(mData){}
	 * @param fnFailureCallback
	 *            失败回调方法，方法格式：function(oRequest, sTextStatus, oErrorThrown)
	 *            此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * @param bSync
	 *           调用方式：同步/异步。true :异步，false:同步，默认为false
	 * 
	 * <pre>
	 * <b>使用举例：</b>
	 *    //传参
	 *	var mParams = {
	 *		&quot;ID&quot; : &quot;1111&quot;,
	 *		&quot;NAME&quot; : &quot;herong&quot;
	 *	};
	 *	
	 *	CFW.oAJax.doService(&quot;bxgxService.query&quot;, mParams, &quot;调用Service &quot;,
	 *		function(mData) {
	 *			//调用成功后返回数据
	 *		}
	 *	);
	 *	
	 *	或：
	 *	
	 *	CFW.oAJax.doService(&quot;bxgxService.query&quot;, mParams, 
	 *			function(mData) {
	 *				//调用成功后返回数据
	 *			}, function(oRequest, sTextStatus, oErrorThrown) {
	 *				//调用失败处理。此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 *			}
	 *	);
	 * </pre>
	 */
	doService : function(sServiceName, mParams,sMessage, fnSuccessCallback,
			fnFailureCallback, bSync) {
		var aServices=[];
		var mShareParameters={};
		var mServices={};
		if(!sServiceName){
			return this;
		}
		var serviceParam=sServiceName.split(".");//service 参数数组，包括service名和方法名
		if(serviceParam.length==0 || serviceParam.length>2){
			CFW.oWin.fnAlert('服务(sServiceName)定义不正确,请核实!');
			return this;
		}
		
		if(!serviceParam[0] || !serviceParam[1]){
			CFW.oWin.fnAlert('服务定义的serviceId和method不可为空');
			return this;
		}
		if(mParams){
			if(typeof mParams !='object'
				||jQuery.isArray(mParams)){
				CFW.oWin.fnAlert('服务定义的参数必须是map！');
				return;
			}
		}
		mServices.serviceId=serviceParam[0];
		mServices.method=serviceParam[1];
		mServices.parameters=mParams;
		aServices.push(mServices);
		var bSync1 = true;
		var fnSuccess = fnSuccessCallback;
		var fnFailure = fnFailureCallback;
		if(bSync!=null&&typeof bSync=='boolean'){
			if(!bSync){
				bSync1 = false;
			}
		}
		this._fnDoAjax(aServices,mShareParameters,sMessage,fnSuccess,fnFailure,bSync1);
		 
	},

	/**
	 * ajax调用存储过程 
	 * 通过ajax直接请求调用存储过程
	 * @param sProcName
	 *            (必需) 业务存储过程全名，格式：包名.过程名
	 * @param mParams
	 *            入参数json对象,key要求大写
	 * @param sMessage
	 *            提示信息
	 * @param fnSuccessCallback
	 *            (必需) 成功回调方法，方法格式：function(mData){}
	 * @param fnFailureCallback
	 *            失败回调方法，方法格式：function(oRequest, sTextStatus, oErrorThrown)
	 *            此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * @param bSync
	 *            调用方式：同步/异步。true :异步，false:同步，默认为false
	 * 
	 * <pre>
	 * <b>使用举例：</b>
	 *   //传参
	 *	var mParams = {
	 *		&quot;ID&quot; : &quot;1111&quot;,
	 *		&quot;NAME&quot; : &quot;herong&quot;
	 *	};
	 *	
	 *	CFW.oAJax.doProc(&quot;pkg_sms.p_test&quot;, mParams, null,
	 *		function(mData) {
	 *			//调用成功后返回数据
	 *		}
	 *	);
	 *
	 *	或：
	 *	
	 *	CFW.oAJax.doProc(&quot;pkg_sms.p_test&quot;, mParams, &quot;调用存储过程&quot;,
	 *		function(mData) {
	 *			//调用成功后返回数据
	 *		}, function(oRequest, sTextStatus, oErrorThrown) {
	 *			//调用失败处理。此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 *		}
	 *	);
	 *
	 * </pre>
	 */
	doProc : function(sProcName, mParams,sMessage,fnSuccessCallback, fnFailureCallback,
			bSync) {
		var aServices=[];
		var mShareParameters={};
		var mServices={};
		if(!sProcName){
			return this;
		}
		if(mParams){
			if(typeof mParams !='object'
				||jQuery.isArray(mParams)){
				CFW.oWin.fnAlert('服务定义的参数必须是map！');
				return;
			}
		}
		mParams['']=sProcName;
		mServices.serviceId='directJdbcService';
		mServices.method='savePointProcedure';
		mServices.parameters=mParams;
		aServices.push(mServices);
		var bSync1 = true;
		var fnSuccess = fnSuccessCallback;
		var fnFailure = fnFailureCallback;
		if(bSync!=null&&typeof bSync=='boolean'){
			if(!bSync){
				bSync1 = false;
			}
		}
		this._fnDoAjax(aServices,mShareParameters,sMessage,fnSuccess,fnFailure,bSync1);

	},

	/**
	 * ajax执行单个查询
	 * 通过ajax直接请求Mapper单个查询
	 * @param sId
	 *            (必需) Mapper配置ID
	 * @param mParams
	 *            入参
	 * @param sMessage
	 *            提示信息
	 * @param fnSuccessCallback
	 *            (必需) 成功回调方法，方法格式：function(mData){}
	 * @param fnFailureCallback
	 *            失败回调方法，方法格式：function(oRequest, sTextStatus, oErrorThrown)
	 *            此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * @param sTransform
	 *            结果集的转换规则：null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写
	 * @param bSync
	 *            调用方式：同步/异步。true :异步，false:同步，默认为false
	 * 
	 * <pre>
	 * <b>使用举例：</b>
	 * 	//传参
	 * 	var mParams = {
	 * 		&quot;ID&quot; : &quot;1111&quot;,
	 * 		&quot;NAME&quot; : &quot;herong&quot;
	 * 	};
	 * 			
	 * 	CFW.oAJax.doQuery(&quot;FW_TEST.TBL_Q&quot;, mParams, &quot;调用Mapper &quot;,
	 * 		 function(mData) {
	 * 			//调用成功后返回数据
	 * 		 }
	 * 	);
	 * 
	 * 	或：
	 * 			
	 * 	CFW.oAJax.doQuery(&quot;FW_TEST.TBL_Q&quot;, mParams,
	 * 		function(mData) {
	 * 			//调用成功后返回数据
	 * 		}, function(oRequest, sTextStatus, oErrorThrown) {
	 * 			//调用失败处理。此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * 		}
	 * 	);
	 * 
	 * </pre>
	 */
	doQuery : function(sId, mParams, sMessage, fnSuccessCallback,
			fnFailureCallback, sTransform, bSync) {
		var aServices=[];
		var mShareParameters={};
		var mServices={};
		if(!sId){
			CFW.oWin.fnAlert('查询服务必须指定configId属性');
			return this;
		}
		if(mParams){
			if(typeof mParams !='object'
				||jQuery.isArray(mParams)){
				CFW.oWin.fnAlert('服务定义的参数必须是map！');
				return this;
			}
		}
		//如果指定了transform，那么值只能是规定的
		if(sTransform){
			if('FIRSTROW'!=sTransform.toUpperCase()
					&&'BREAKDOWN'!=sTransform.toUpperCase()){
				CFW.oWin.fnAlert('transform属性不正确');
				return this;
			}
		}
		mParams["_commDo"]=sId;
		mServices.serviceId='commService';
		mServices.method='query';
		mServices.parameters=mParams;
		mServices.transform=sTransform;
		aServices.push(mServices);
		var bSync1 = true;
		var fnSuccess = fnSuccessCallback;
		var fnFailure = fnFailureCallback;
		if(bSync!=null&&typeof bSync=='boolean'){
			if(!bSync){
				bSync1 = false;
			}
		}
		this._fnDoAjax(aServices,mShareParameters,sMessage,fnSuccess,fnFailure,bSync1);

	},

	/**
	 * ajax混合调用,同时调用多个操作
	 * <pre> 同时调用多个操作 在同一个事物中同时调用多个Action， action: 服务Id，不可为空 
	 * transform： 结果集的转换规则（返回结果集合List<Map<String,Object>>时才会用到）：
	 * 			  null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写。
	 * 			  默认不转换。
	 * shareResults： 共享服务的返回结果，默认不共享false，如果后续服务需要使用到结果里面的参数， 那么就需要明确指定。该参数可以是
	 * 		boolean,array或者object，规则如下： 如果值为true时表示全部共享；
	 * 		如果值为array数组，则可以指定返回值中需要共享的值的名，这样返回值的键值对应关系共享；
	 * 		如果值为object对象，则可以额外指定共享名的别名，当要求返回值以新的字段名共享、
	 * 			或者一个以多个新别名共享时就需要用到这种类型，object的属性名表示结果集中需要共享的字段名，属性值表示新的字段名；
	 * 		参数共享处理列表结果集时，整个结果集的数据存放在别名为空串的特殊key上。如果本业务没有返回结果，那么参数共享无效。 
	 * useShare：
	 * 		使用共享参数标志，定义方式与shareResults一样，意义正好想对应。该参数指明是否从共享参数中获取要的值。默认不共享。 
	 * shareNotNull：
	 * 		校验共享参数是否为空，作为useShare的附属属性，默认不校验。 有时希望如果获取到的共享参数是空的，那么不继续执行，那么可以在这里指定哪些一定不能为空。
	 * 		目前只允许三种取值，null,true和别名数组: 
	 * 		null(即不指定参数值）表示不校验；
	 * 		true表示全校验，别名数组表示只校验指定的值（别名是指useShare中新的别名，并非共享池里面的共享别名）。 </pre>
	 * 
	 * @param aActions
	 *            (必需) 操作定义,格式： [
	 *            {"action":"action1","transform":"","shareResults":"false","useShare":"","shareNotNull":""},
	 *            {"action":"action2","transform":"","shareResults":"false","useShare":"","shareNotNull":""} ]
	 * 
	 * @param mParams
	 *            入参,必须是object，object的属性名代表参数名，属性值代表参数值。 
	 * @param sMessage
	 *            提示信息
	 * @param fnSuccessCallback
	 *            (必需) 成功回调方法，方法格式：function(mData){}
	 * @param fnFailureCallback
	 *            失败回调方法，方法格式：function(oRequest, sTextStatus, oErrorThrown)
	 *            此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * @param bSync
	 *            调用方式：同步/异步。true :异步，false:同步，默认为false
	 * 
	 * <pre>
	 * <b>使用举例：</b>
	 * 	var action1 = [
	 * 		{&quot;action&quot;:&quot;bxgxService.query&quot;},
	 *      {&quot;action&quot;:&quot;pkg_sms.p_test&quot;} 
	 *  	];
	 *            
	 *  var action2 = [
	 * 		{&quot;action&quot;:&quot;bxgxService.query&quot;,&quot;transform&quot;:&quot;firstRow&quot;,&quot;shareResults&quot;:&quot;true&quot;,&quot;useShare&quot;:&quot;&quot;,&quot;shareNotNull&quot;:&quot;&quot;},
	 *      {&quot;action&quot;:&quot;pkg_sms.p_test&quot;,&quot;transform&quot;:&quot;&quot;,&quot;shareResults&quot;:&quot;false&quot;,&quot;useShare&quot;:&quot;true&quot;,&quot;shareNotNull&quot;:&quot;&quot;} 
	 *      ];  
	 * 	//传参
	 * 	var mParams = {
	 * 		&quot;ID&quot; : &quot;1111&quot;,
	 * 		&quot;NAME&quot; : &quot;herong&quot;
	 * 		};
	 * 			
	 * CFW.oAJax.doAction(action1, mParams, &quot;混合调用 &quot;,
	 * 		function(mData) {
	 * 			//调用成功后返回数据
	 * 		}
	 * 	);
	 * 
	 * 	或：
	 * 			
	 * CFW.oAJax.doAction(action2, mParams, 
	 * 		function(mData) {
	 * 			//调用成功后返回数据
	 * 		}, function(oRequest, sTextStatus, oErrorThrown) {
	 * 			//调用失败处理。此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * 		}
	 * 	);
	 * 
	 * </pre>
	 */
	doAction : function(aActions, mParams, sMessage,fnSuccessCallback,
			fnFailureCallback, bSync) {
		if(aActions.length==0){
			CFW.oWin.fnAlert('请至少添加一个服务');
			return;
		}
		var aServices=[];
		var mShareParameters={};
		for(var index=0; index<aActions.length;index++){
			var mServices={};
			var action=aActions[index].action;
			if(!action){
				CFW.oWin.fnAlert('action不能为空,请核实!');
				return;
			}
			var exec = action.split(".");
			if(exec.length!=2){
				CFW.oWin.fnAlert('action格式不正确,请核实!');
				return;
			}
			var prefix = exec[0];
			
			if(prefix.lastIndexOf("Service")>0){//如果是service
				$.extend(true,mServices,{parameters:mParams},
						{serviceId:exec[0],method:exec[1]});
			}else if(action.toLowerCase().match('^pkg_\\w+\\.\\w+$')){//如果是存储过程
				$.extend(true,mServices,{parameters:mParams},
						{serviceId:'directJdbcService',method:'savePointProcedure'
							,parameters:{'':action}});
			}else{//其余的为mapper
				$.extend(true,mServices,{parameters:mParams},
						{serviceId:'commService',method:'query'
							,parameters:{'_commDo':action}});
			}
			
			//如果指定了transform，那么值只能是规定的
			if(aActions[index].transform){
				if('FIRSTROW'!=aActions[index].transform.toUpperCase()
						&&'BREAKDOWN'!=aActions[index].transform.toUpperCase()){
					CFW.oWin.fnAlert('transform属性不正确');
					return this;
				}
				mServices.transform=aActions[index].transform;
			}
			//shareResults
			//转换shareResults，统一转换成map，或者boolean
			shareResults = aActions[index].shareResults;
			if(shareResults){
				if(typeof shareResults =='boolean'){
					if(!shareResults){
						shareResults =null;
					}
				}else if(jQuery.isArray(shareResults)){
					//转化为map
					shareResults={};
					$.each(aActions[index].shareResults,function(indexInArray, valueOfElement){
						shareResults[valueOfElement]=valueOfElement;
					});
					
				}
				mServices.shareResults =shareResults;
			}
			//useShare
			useShare = aActions[index].useShare;
			if(useShare){
				if(typeof useShare =='boolean'){
					if(!useShare){
						useShare =null;
					}
				}else if(jQuery.isArray(useShare)){
					//转化为map
					useShare={};
					$.each(aActions[index].useShare,function(indexInArray, valueOfElement){
						useShare[valueOfElement]=valueOfElement;
					});
					
				}
				mServices.useShare =useShare;
			}
			//shareNotNull，只允许true和字符串数组
			shareNotNull = aActions[index].shareNotNull;
			if(shareNotNull){
				if(typeof shareNotNull !=='boolean' && !jQuery.isArray(shareNotNull)){
					CFW.oWin.fnAlert('参数[shareNotNull]的取值必须是true或者字符串数组！');
					return this;
				}else if(shareNotNull ===false){
					shareNotNull = null;
				}
				mServices.shareNotNull = shareNotNull;
			}
			aServices.push(mServices);
			
		}
		var bSync1 = true;
		var fnSuccess = fnSuccessCallback;
		var fnFailure = fnFailureCallback;
		if(bSync!=null&&typeof bSync=='boolean'){
			if(!bSync){
				bSync1 = false;
			}
		}
		this._fnDoAjax(aServices,mShareParameters, sMessage,fnSuccess,fnFailure,bSync1);

	},
	
	/**
	 * ajax将参数转换成model直接调用action
	 * 
	 * @param oper
	 *           调用的action名称和方法名以"."分隔
	 * 
	 * @param params
	 *            共享参数
	 * @param datas
	 *            模型对象 离散型参数以"ncm_gt_"开头,格式为{ncm_gt_XXXX:{params:{AAC001:'xxxx','AAB010':'xxxxx'}}}
	 *                    列表行参数以"ncm_glt_"开头,格式为 {ncm_glt_XXXX:{dataset:[{AAC001:'xxxx','AAB010':'xxxxx'},{AAC001:'xxxx','AAB010':'xxxxx'}]}}         
	 * @param sMessage
	 *            提示信息
	 * @param fnSuccessCallback
	 *            (必需) 成功回调方法，方法格式：function(mData){}
	 * @param fnFailureCallback
	 *            失败回调方法，方法格式：function(oRequest, sTextStatus, oErrorThrown)
	 *            此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * @param bSync
	 *            调用方式：同步/异步。true :异步，false:同步，默认为false
	 * 
	 */
	fnDoAjaxModel : function(oper,params,datas,sMessage,fnSuccessCallback,fnFailureCallback,bSync){
		var tdata={};
		tdata.oper=oper;
		tdata.params=params;
		tdata.datas=datas;
		var mRequest={};
		if(!sMessage){
			sMessage='正在请求服务，请稍候...';
		}else if(typeof sMessage != 'string'){
			CFW.oWin.fnAlert('入参错误，请检查程序！');
			return ;
		}
		var fnShowMSG=this._fnShowMsg(sMessage, -1);
		if(AJAX_SHOW_PROCESSBAR){
			CFW.oTip.fnOpenProcess();
		}
		$.ajax({
			url:contextPath+'/ajaxModel.do'
	 		,data:{params:JSON.stringify(tdata)}
			,dataType :'json'
			,cache:false
			,async:bSync
			,contentType: "application/x-www-form-urlencoded; charset=utf-8"
			,type:'post'
			,error:function (request, textStatus, errorThrown) {
				if(!fnFailureCallback){
					CFW.oWin.fnAlert('数据请求错误!');
				}else{
					fnFailureCallback('数据请求错误!', {'type':'App'});
				}
			}
			,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(fnFailureCallback){
							fnFailureCallback(data.MSG||'', {'type':data.FHZ}, data.MSG);
						}else{
							CFW.oWin.fnAlertStyle(data.MSG||'',{'type':data.FHZ});
						}
					}
				}else if(!fnSuccessCallback){
					
				}else{
					fnSuccessCallback(data.RTN);
				}
			}
			,beforeSend:function(XMLHttpRequest){
				var cToken = $.cookie(headtoken) || token;XMLHttpRequest.setRequestHeader(headtoken,cToken); 
				$.data(mRequest,'msg',fnShowMSG);
				//createProgressBar();
			}
			,complete:function( ){
				jQuery($.data(mRequest,'msg')).remove();
				if(AJAX_SHOW_PROCESSBAR){
					CFW.oTip.fnCloseProcess();
				}
			}
		 });	
	},
	
	/**
	 * ajax混合调用,同时调用多个操作
	 * <pre> 同时调用多个操作 在同一个事物中同时调用多个Action， action: 服务Id，不可为空 
	 * transform： 结果集的转换规则（返回结果集合List<Map<String,Object>>时才会用到）：
	 * 			  null（无转换）、'firstRow'（取首行）、'breakdown'（分列），值不区分大小写。
	 * 			  默认不转换。
	 * shareResults： 共享服务的返回结果，默认不共享false，如果后续服务需要使用到结果里面的参数， 那么就需要明确指定。该参数可以是
	 * 		boolean,array或者object，规则如下： 如果值为true时表示全部共享；
	 * 		如果值为array数组，则可以指定返回值中需要共享的值的名，这样返回值的键值对应关系共享；
	 * 		如果值为object对象，则可以额外指定共享名的别名，当要求返回值以新的字段名共享、
	 * 			或者一个以多个新别名共享时就需要用到这种类型，object的属性名表示结果集中需要共享的字段名，属性值表示新的字段名；
	 * 		参数共享处理列表结果集时，整个结果集的数据存放在别名为空串的特殊key上。如果本业务没有返回结果，那么参数共享无效。 
	 * useShare：
	 * 		使用共享参数标志，定义方式与shareResults一样，意义正好想对应。该参数指明是否从共享参数中获取要的值。默认不共享。 
	 * shareNotNull：
	 * 		校验共享参数是否为空，作为useShare的附属属性，默认不校验。 有时希望如果获取到的共享参数是空的，那么不继续执行，那么可以在这里指定哪些一定不能为空。
	 * 		目前只允许三种取值，null,true和别名数组: 
	 * 		null(即不指定参数值）表示不校验；
	 * 		true表示全校验，别名数组表示只校验指定的值（别名是指useShare中新的别名，并非共享池里面的共享别名）。 </pre>
	 * 
	 * @param aServices
	 *           service数组
	 * 
	 * @param mShareParameters
	 *            共享参数
	 * @param sMessage
	 *            提示信息
	 * @param fnSuccessCallback
	 *            (必需) 成功回调方法，方法格式：function(mData){}
	 * @param fnFailureCallback
	 *            失败回调方法，方法格式：function(oRequest, sTextStatus, oErrorThrown)
	 *            此回调可以根据情况覆盖框架默认错误处理，框架默认错误处理已满足大部分需求。
	 * @param bSync
	 *            调用方式：同步/异步。true :异步，false:同步，默认为false
	 * 
	 */
	_fnDoAjax : function(aServices,mShareParameters,sMessage,fnSuccessCallback,fnFailureCallback,bSync){
		var mRequest={};
		if(!sMessage){
			sMessage='正在请求服务，请稍候...';
		}else if(typeof sMessage != 'string'){
			CFW.oWin.fnAlert('入参错误，请检查程序！');
			return ;
		}
		var fnShowMSG=this._fnShowMsg(sMessage, -1);
		if(AJAX_SHOW_PROCESSBAR){
			CFW.oTip.fnOpenProcess();
		}
		$.ajax({
			url:contextPath+'/ajaxAdapter.do'
			,data:{parameters:JSON.stringify(aServices),shareArguments:JSON.stringify(mShareParameters)}
			,dataType :'json'
			,cache:false
			,async:bSync
			,contentType: "application/x-www-form-urlencoded; charset=utf-8"
			,type:'post'
			,error:function (request, textStatus, errorThrown) {
				if(!fnFailureCallback){
					CFW.oWin.fnAlert('数据请求错误!');
				}else{
					fnFailureCallback('数据请求错误!', {'type':'App'});
				}
			}
			,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);
						if(fnFailureCallback){
							fnFailureCallback(data.MSG||'', {'type':data.FHZ}, data.MSG);
						}
						return;
					
					} else {
						if(fnFailureCallback){
							fnFailureCallback(data.MSG||'', {'type':data.FHZ}, data.MSG);
						}else{
							CFW.oWin.fnAlertStyle(data.MSG||'',{'type':data.FHZ});
						}
					}
				}else if(!fnSuccessCallback){
					
				}else{
					fnSuccessCallback(data.RTN);
				}
			}
			,beforeSend:function(XMLHttpRequest){
				var cToken = $.cookie(headtoken) || token;XMLHttpRequest.setRequestHeader(headtoken,cToken); 
				$.data(mRequest,'msg',fnShowMSG);
				//createProgressBar();
			}
			,complete:function( ){
				jQuery($.data(mRequest,'msg')).remove();
				if(AJAX_SHOW_PROCESSBAR){
					CFW.oTip.fnCloseProcess();
				}
			}
		 });	
	},
	/**
	* 在页面的左上角显示错误消息
	* @param sMsg 消息内容
	* @param iDelay 秒为单位,0或者负数表示不自动隐藏
	**/
	_fnShowMsg : function(sMsg,iDelay){
		var framework_message_layer;
		var clearIntervalID;
		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=sMsg;
		framework_message_layer.appendChild(my_div);
		recurrectLocation();
		if(iDelay>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;
				}
			},iDelay*1000);
		}else{
			return my_div;
		}
	}
};