ajax.js

/**通用ajax服务的定义对象

 * services可以是单个服务对象，也可以是service服务数组
 * 具体服务的定义请参考appendServices成员函数
 */
function Service(services){
    //一直到299行
    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){//到128行
        if(!services){
            return this;
        }
        //默认按批量形式添加服务，如果是单个，那么用数组包装

        var tmp_services=services;
        if(!$.isArray(tmp_services)){
            tmp_services = [tmp_services];
        }
        //每个service必须有serviceId，method
        for(index in tmp_services){
            //检查必录项
            if(!tmp_services[index].serviceId||!tmp_services[index].method){
                FWalert('服务定义的serviceId和method不可为空');
                return this;
            }
            //检查可选项
            if(tmp_services[index].parameters){
                if(typeof tmp_services[index].parameters !='object'
                    ||jQuery.isArray(tmp_services[index].parameters)){
                    FWalert('服务定义的参数必须是map！');
                    return;
                }
            }
            //如果指定了transform，那么值只能是规定的

            if(tmp_services[index].transform){
                if('FIRSTROW'!=tmp_services[index].transform.toUpperCase()
                        &&'BREAKDOWN'!=tmp_services[index].transform.toUpperCase()){
                    FWalert('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)){
                    FWalert('参数[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){
        如果传入的参数是空，null,''等，那么就返回该对象，实际上就是返回 new Service() 这个对象，@wyl
        if(!procedures){
            return this;
        }
        默认按批量形式添加服务，如果是单个，那么用数组包装
        如果传入的不是数组，那么就把这个对象包装成数组，@wyl,并且用临时变量存起来
        tmp_procedures=procedures;
        if(!$.isArray(tmp_procedures)){
            tmp_procedures = [tmp_procedures];
        }
        //遍历，一个一个的处理
        procedure_services =[];
        for (index in tmp_procedures){
            //必须有configId属性

            procedure = tmp_procedures[index];
            if(!procedure.procName){
                FWalert('存储过程服务必须指定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 (index in tmp_querys){
            //必须有configId属性

            var query = tmp_querys[index];
            if(!query.configId){
                FWalert('查询服务必须指定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){
        if(this.services.length==0){
            FWalert('请至少添加一个服务');
            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'){
            FWalert('入参错误，请检查程序！');
            return ;
        }
        if(async!=null&&typeof async=='boolean'){
            if(!async){
                t_async = false;
            }
        }
        var thisrequest={};
         $.ajax({
            url:contextPath+'/ajax.do'
            ,data:{parameters:JSON.stringify(this.services),shareArguments:JSON.stringify(this.shareParameters)}
            ,dataType :'json'
            ,cache:false
            ,async:t_async
            ,type:'post'
            ,error:function (request, textStatus, errorThrown) {
                if(!t_error){
                    FWalert('数据请求错误！');    
                }else{
                    t_error(request, textStatus, errorThrown);
                }
                }
            ,success:function (data, textStatus) {
                //校验业务处理是否正确执行
                if("1"!=data.FHZ){//出错了，弹出错误提醒
                    if ("loginTimeout" == data.FHZ) {
                        if(window.confirm(data.MSG||'')){
                            window.top.location.href=_selfUrl;
                        }
                    } else {
                        if(t_error){
                            t_error(data.MSG||'', 'serviceErr', data.MSG);
                        }else{
                            FWalert(data.MSG||'');
                        }
                    }
                }else if(!t_success){
                }else{
                    t_success(data.RTN);
                }
            }
            ,beforeSend:function( ){
                $.data(thisrequest,'msg',showMsg(t_message,-1));
                //createProgressBar();
            }
            ,complete:function( ){
                hideMsg($.data(thisrequest,'msg'));
            }
         });
    };
    //添加参数
    if(services){
        this.appendServices(services);
    }
}
/**
* 在页面的左上角显示错误消息

* @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;
    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();
}