/*
此函数为ajax区域 要求所有后台请求来自于这里
应该5秒内返回给用户一个提示信息。涉及到提示信息可以传递时间参数到此ajax，如果5秒未收到结果，则弹出重试的提示。
ajax 跨域有问题 没有到回调里面去
*/

/*
变量命名编写规范：
变量类型   变量名称
string       str
object       obj。
Array        arr
Element      el
bool         b
用户信息     userinfo
硬盘信息     diskinfo
好友信息     frindinfo
群信息       groupinfo
回调callback       cb
函数         fun
错误         err
参数数组aruguments   arg    
*/


//补充错误的定义。
//错误状态写在r.request.status里面。如果r.request.status==200,则表示成功。其余状态码表示有错误，如果是我们系统发生错误，统一状态码为500,即r.request.status==500，其他由web服务器自己决定。
//详细错误信息在r.value里面.


Namespace.register("U.A");

//#region

//所有请求的ajax对象.
U.A.ASet = [];

//数据库访问地址
U.A.DataBase = {
    Reply: ["Mysql", "UseStudio_Reply"], //回复系统
    Money: ["Mysql", "UseStudio_Pay"], //交易系统
    Develop: ["Mysql", "UseStudio_Develop"] //在线编程平台
};

//云端访问地址
U.A.backAddress = {
    //前端系统统一处理
    UseStudioManage: "http://main.1473.cn/Uses.ashx", //main
    UseStudioDisk: "http://main.1473.cn/Uses.ashx", //disk
    pb: "http://main.1473.cn/Uses.ashx", //学习系统
    Blog: "http://main.1473.cn/Uses.ashx", //blog
    Application: "http://main.1473.cn/Uses.ashx", //站外应用
    ABlog: "http://main.1473.cn/admin.ashx", //admin blog
    APB: "http://main.1473.cn/admin.ashx", //admin pb
    AUser: "http://main.1473.cn/admin.ashx", //admin user
    ADisk: "http://main.1473.cn/admin.ashx", //admindisk
    AApp: "http://main.1473.cn/admin.ashx", //application
    Verify: "http://admin.1473.cn/Verify", //admin 虚拟币
    Upload: "http://main.1473.cn/USupfile.ashx", //上传



    //后端系统处理
    Admin: "http://admin.1473.cn/Admin/Admin.ashx", //admin 自带后台
    KF: "http://admin.1473.cn/Admin/Admin.ashx", //admin 统计


    office: "http://office.1473.cn/Officetohtml.ashx", //office
    UseStudioPay: "http://pay.1473.cn/UseStudioPay.ashx", //交易
    Reply: "http://reply.1473.cn" //回复
}

//U.A.backAddress = {
//    office: "http://main.1473.cn/Mian.ashx", //office
//    Upload: "http://disk.1473.cn/USupfile.ashx", //上传
//    UseStudioManage: "http://main.1473.cn/Uses.ashx", //main
//    UseStudioDisk: "http://main.1473.cn/Uses.ashx", //disk
//    pb: "http://main.1473.cn/Uses.ashx", //学习系统
//    Application: "http://app.1473.cn/application.ashx", //站外应用
//    Blog: "http://main.1473.cn/Uses.ashx", //blog
//    UseStudioPay: "http://pay.1473.cn/UseStudioPay.ashx", //交易
//    Reply: "http://reply.1473.cn", //回复
//    AApp: "http://admin.1473.cn/Application/AApp.ashx", //application
//    ABlog: "http://admin.1473.cn/APB/APB.ashx", //admin blog
//    APB: "http://admin.1473.cn/APB/APB.ashx", //admin pb
//    AUser: "http://admin.1473.cn/User/Users.ashx", //admin user
//    Verify: "http://admin.1473.cn/Verify", //admin 虚拟币
//    Admin: "http://admin.1473.cn/Admin/Admin.ashx", //admin 自带后台
//    ADisk: "http://admin.1473.cn/Disk/ADisk.ashx", //admindisk
//    KF: "http://admin.1473.cn/system/KF.ashx" //admin 统计
//}

//#endregion

/**
* ajax初始化区域
*
* @param  {string} 访问的地址
* @param  {array} 数据库地址，数据库名，存储过程名，存储过程参数的数组
* @param  {function} 回调函数
* @param  {array} 函数传参
* @returns {object} ajax对象 
-----------这里的传参第一个为loading元素
*/
// 删除了一个参数 UCE
U.A.Request = $.ajax = function (str, db, cb) {

    //判断浏览器是否在线联网
    if (U.M.IsNetwork()) {
        var _ajax, //获取所有的传参,参数说明 win 当前域 、 UR ajax原对象 、 EOR 错误回调函数 、 UFN 触发的函数地址 、 UDE 服务器传参 、 UCB 回调函数    UPE 回调参数 、 UAE ajax对象属性 、 UTI当前使用时间
            _preAjax = U.A.ASet[U.A.ASet.length - 1]; //ajax对象
        //判断ajax的时间差，防止恶意用户用循环向服务器不断发送请求，导致服务器瘫痪。
        //恶意请求大于了50次，则判断此用户有恶意攻击嫌疑。
        //计算两次ajax请求的时间差
        var _ifTimeSpan;
        if (_preAjax) {
            _ifTimeSpan = new Date().getTime() - _preAjax.date > 50;
        }
        //如果第一次ajax请求，或者ajax请求小于50次。或者2次发送请求的时间差大于50毫秒，都算没有恶意请求。
        if (!_preAjax || _preAjax.timeSpan < 50 || _ifTimeSpan) { //连续发送禁止处理
            _ajax = new U.A.Request.init(arguments); //生成ajax对象

            //此处添加二级域名跨域，完全跨域，无跨域的分支。
            if (_ajax.handleDomain() === true) {
                //添加有header和无header的两个分支。
                if (_ajax.header) {
                    return _ajax.createHeader(_ajax.header); //创建连接，添加header的目的是可以自己构建header
                } else {
                    return _ajax.create(); //创建连接，无header分支
                }
                // return _ajax.create(_ajax.header); //创建连接，添加header的目的是可以自己构建header
            }
        }
        return { "error": "application has been breached" }; //连接过多错误
    } else { U.Alert("网络断开！"); }
}

/**
* ajax初始化区域
*
* @param  {array} ajax参数
----------[0] 访问的地址
----------[1] 服务器传参
----------[2] 回调函数
----------[3] 函数传参
-----------这里的传参第一个为loading元素
*/
U.A.Request.init = function (arg) { //初始化Ajax对象
    /*
    参数说明 win 当前域 、 UR ajax原对象 、 EOR 错误回调函数 、 UFN 触发的函数地址 、 UDE 服务器传参 、 UCB 回调函数
    UPE 回调参数 、 UAE ajax对象属性 、 UTI当前使用时间
    */
    //this.win = window; // win 当前域
    //ajax原对象{ TO: _UAE, D: this.UTI, N: this.UFN, J: (_UOE && ((new Date().getTime() - _UOE.D) < 50)) ? _UOE.J + 1 : _UOE ? _UOE.J : 0 }
    //U.A.Request调用示例：U.A.Request("http://cd.1473.cn/php", ["mysql.1473.cn", "CloudSqlTestDb", "selectAllData"],function (r){})
    U.Ut.AddObj(this, {
        win: window, // win 当前域
        ajax: null, //ajax原对象{ TO: _UAE, D: this.UTI, N: this.UFN, J: (_UOE && ((new Date().getTime() - _UOE.D) < 50)) ? _UOE.J + 1 : _UOE ? _UOE.J : 0 }  在函数CA里面最后一句话会发送此ajax
        err: null, //  err   error是系统关键字
        url: arg[0], // url   ）。后台地址，形如"http://cd.1473.cn/php"。
        //ajax向后台请求的传参，其形式为：["mysql.1473.cn", "CloudSqlTestDb", "selectAllData","guid","str"]，包含了数据库地址，数据库名，数据库存储过程名称，数据库参数...如果没有，则新建一个空数组，用法：var e = U.A.Request("http://cd.1473.cn/ss");.则e为后台返回的值。
        //UDE改成db
        db: arg[1] || [],
        cb: arg[2] || "", //回调函数  cb   
        cbParams: arg[3], //回调参数  cbparams
        //调用方法：U.A.Request(US.Auth,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.NU, US.NLInfo.LogAddr || "", US.ITID], U.M.apply(), [], { type: "Get", "async": false, "timeout": 1, "CONTENT-TYPE": "application/json" }); //访问日志添加消息
        header: arg[4] || "", //暂时没有用处。浏览器升级后对ajax的功能进行扩展，加入了"对head头部自定义修改"的功能。CONTENT-TYPE:application/x-www-form-urlencoded;charset=UTF-8.
        UTI: new Date() //ajax生成时间..删除，时间保存在第二个参数ajax里面。
    }); //使用参数区域
}

U.A.Request.init.prototype = {
    createHeader: function (header) {
        var i, _url, _isDomain, _db, _ajax, isAsync, r;
        var ajaxType = header.type; //用户请求类型，默认1473全部是post请求。
        var _USE = this.toAjaxFormat(); //生成请求参数 数据结构：
        _url = _USE[0]; //连接的后台地址 形如"http://cd.1473.cn/php" 
        _db = _USE[1]; //传参参数;  
        //如果不传递回调函数，则为同步请求，示例：U.A.Request(US.Auth,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.NU, US.NLInfo.LogAddr || "", US.ITID]);。返回json数据，一直等待服务器返回，如果服务器执行1分钟，页面停顿1分钟。
        if (U.Ut.isFunction(this.cb)) {
            isAsync = true; //函数是否异步
        }
        //如果请求为get
        if (ajaxType.toUpperCase() == "GET") {
            _url += "?" + _db;
        }
        this.ajax = this.CA(_url); //生成ajax对象
        _ajax = this.ajax.systemAjax; //获取系统ajax对象
        _ajax.open(ajaxType, _url, isAsync); //设置ajax请求方法 url 是否异步

        header["CONTENT-TYPE"] = header["CONTENT-TYPE"] || "application/x-www-form-urlencoded;charset=UTF-8"
        //设置请求参数
        for (i in header) {
            if ("type,async".indexOf(i) == -1) {
                try {
                    if (i in _ajax) {
                        _ajax[i] = header[i];
                    } else {
                        _ajax.setRequestHeader(i, header[i]);
                    } //设置head头部
                } catch (e) { }
            }
        }
        // 指定服务器返回数据的MIME类型 firfox设置兼容
        if (_ajax.overrideMimeType) {
            if (header["responseType"] == "blob") {
                _ajax.overrideMimeType("text/plain; charset=x-user-defined");
            } else {
                _ajax.overrideMimeType("text/html");
            }
        }
        //发送请求
        _ajax.send(_db);

        //得到服务器返回的值，一般为json，也可能为字符串。如果是异步，则走异步逻辑，否则走同步逻辑
        if (isAsync) {
            r = this["async"]();
        } else {
            r = this["sync"]();
        }
        //返回
        return _isDomain;
    },
    /**
    * Ajax对象创建
    *
    * @param  {object} ajax属性
    */
    create: function () {
        var header = {};
        var i, _url, _isDomain, _db, _ajax, isAsync, r;
        var ajaxType = "POST"; //用户请求类型，默认1473全部是post请求。
        var _params = this.toAjaxFormat(); //生成请求参数 数据结构：
        _url = _params[0]; //连接的后台地址 形如"http://cd.1473.cn/php" 
        _db = _params[1]; //传参参数;  
        //如果不传递回调函数，则为同步请求，示例：U.A.Request(US.Auth,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.NU, US.NLInfo.LogAddr || "", US.ITID]);。返回json数据，一直等待服务器返回，如果服务器执行1分钟，页面停顿1分钟。
        if (U.Ut.isFunction(this.cb)) {
            isAsync = true; //函数是否异步
        }
        //如果请求为get
        if (ajaxType.toUpperCase() == "GET") {
            _url += "?" + _db;
        }
        //设置请求超时时间
        if (isAsync) {
            // 给header对象添加属性
            header.timeout = 90000;
            header.ontimeout = function () { this.AE(); }
        }
        //指定相应的http内容类型
        //  header["CONTENT-TYPE"] = "application/x-www-form-urlencoded;charset=UTF-8";

        this.ajax = this.CA(_url); //生成ajax对象
        _ajax = this.ajax.systemAjax; //获取系统ajax对象
        _ajax.open(ajaxType, _url, isAsync); //设置ajax请求方法 url 是否异步
        // 指定服务器返回数据的MIME类型 firfox设置兼容
        _ajax.setRequestHeader("CONTENT-TYPE", "application/x-www-form-urlencoded;charset=UTF-8");

        // 指定服务器返回数据的MIME类型 firfox设置兼容
        if (_ajax.overrideMimeType) {
            _ajax.overrideMimeType("text/html");
        }

        //发送请求
        _ajax.send(_db);

        //得到服务器返回的值，一般为json，也可能为字符串。
        if (isAsync) {
            r = this["async"]();
        } else {
            r = this["sync"]();
        }
        //返回
        return r;
    },
    /**
    * 根据请求的url判断域名是否存在跨域。三种跨域情况
    * @return 
    */
    handleDomain: function () {
        //1、二级域名跨域，一般是a.1473.cn访问b.1473.cn。。可能是正常访问，也可能是iframe访问。，
        //2、完全跨域。www.a.com访问www.b.com。  
        //3、没有跨域的情况

        var _isDomain, _url, _frame;
        var _params = this.toAjaxFormat(); //生成请求参数 数据结构：
        _url = _params[0]; //连接的后台地址 形如"http://cd.1473.cn/php" 
        _isDomain = this.isDomain(_url);
        //1473跨域处理，判断是否是1473域，如果不是，则是外域调用
        if (_isDomain[0] && !_isDomain[1]) { // 判断是否是1473主域
            //如果是1473域的处理
            _frame = window.frames; //所有加载的域，对1473域下所有iframe进行循环，目的是找到可跨域的iframe。
            for (i = 0; i < _frame.length; i++) {
                try {
                    if (!_url.indexOf(_frame[i].location.protocol + "//" + _frame[i].location.host)) { //找到指定的跨域
                        return _frame[i].U.A.Request(this.url, this.db, this.cb, this.cbParams, this.header); //跨域获取
                    }
                } catch (e) { }
            }
        }
        //完全跨域判断非1473的域名， 
        else if (!_isDomain[1] && _url.indexOf("1473.cn") > -1 && $("#U_Domain")[0]) { //其他域名跨域处理
            //其他站点，跨域形式访问：例如：http://a.com/ 在页面中调用U.A.Request(US.Auth,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.NU, US.NLInfo.LogAddr || "", US.ITID]);
            this.goDomain(); //外站跨域调用
            return false;
        }
        return true;
    },
    //把传参格式转换为Ajax请求格式
    //              刑如：US.Auth,"UseStudioManage.AddToLoginLog", [US.userInfo.userid || US.NU, US.NLInfo.LogAddr || "", US.ITID]  转换为下面的格式
    //              格式："http://main.1473.cn/Uses.ashx",US.userInfo.userid || US.NU +"&" + US.NLInfo.LogAddr || ""+ "&" + US.ITID, "http://main.1473.cn/Uses.ashx"（默认请求地址，如果第一个参数不在U.A.backAddress中，则使用第三个）
    /*
    * @return  {array} 域、 加密参数、 默认地址  例：
    */
    toAjaxFormat: function () {
        var _userInfo, _useUrl, _defaultUrl,
            _requestObj = U.A.backAddress, //1473请求地址区域
            _url = this.url, //这个是请求参数
            _params = U.M.SplitArray(this.db.concat()), //参数进行加密
            _source = _url.indexOf(":") > -1 && U.M.IsUrl(_url), //判断来源是否是链接
            _requestArr = _url.split("."), //这里拆分1473的请求
            _reqConfig = U.A.DataBase[_requestArr[0]]; //非主系统的外系统的请求配置
        if (_source || _reqConfig) { //非指定云端链接
            if (_reqConfig) {
                _url = _requestObj[_requestArr[0]];
                _params += "&DBTYPE=" + _reqConfig[0] + "&DBNAME=" + _reqConfig[1]; //1473主站点插件区域   
            }
            _useUrl = _url;
            _params = "mode=" + _params; //设置传参
        }
        else if (_requestArr && _requestArr[0] && _requestObj[_requestArr[0]]) { //云端的请求
            _defaultUrl = _requestObj[US.Auth, "UseStudioManage"]; //默认地址
            _useUrl = _requestObj[_requestArr[0]]; //选择的地址
            _params = "functionname=" + _url + "&" + _url + "=" + _params;
        }
        else {
            _useUrl = window.location;
            _useUrl = window.location ? _useUrl.protocol + "//" + _useUrl.host + "/" + _url : "./" + _url;
            _params = "mode=" + _params;
        } //外站请求
        //1473传参 + this.LIDZ()
        try {
            //用户个人信息
            if (parent.US) {
                //传递用户id，后台安全判断及处理
                _userInfo = parent.US.userInfo;
                if (_userInfo && _userInfo.UserId) {
                    _params += "&UserId=" + _userInfo.UserId + "&LoginId=" + _userInfo.LoginId;
                }
            }
            else {
                _userInfo = {};
            }
        }
        catch (e) { _userInfo = {}; }
        //设置1473项目传参的id
        _params += "&PageId=" + US.PageId + "&LoginId=" + US.SystemId;
        //请求的地址，参数，请求的后台函数名
        return [_useUrl, _params, _defaultUrl];
    },

    //完全跨域设置（此处非1473域名区域）处理区域
    goDomain: function () {
        // 获取回调参数
        var _loading = this.cbParams ? this.cbParams[0] : null;
        // 加载loading
        if (_loading) {
            U.MD.loading(_loading[0])
        } else {
            U.MD.loading(_loading, _loading[1])
        }
        // (_UDE) && (U.MD.loading(_UDE[0] || _UDE, _UDE[1])); //设置loading
        // 页面消息传递
        U.MN.message({
            "obj": "#U_Domain",
            "Sender": true, //消息发送
            "me": U.M.apply(this, function (_data) { //消息回调
                var _USE = _data[2].split("=");
                //后台设置了cookie 前台同时响应
                if (_USE[1] == "") {
                    U.M.Cookies.del(_USE[0]);
                } else {
                    U.M.Cookies.set(_data[2]);
                }
                document.wincookie = _data[2]; //记录cookie
                (this.AE) && (this.AE(true, _data[0])); //回调函数
            })
        }).post([this.url, this.db], "domain"); //跨域传参
    },

    /**
    * 获取链接地址
    *
    * @param  {url} 连接地址
    -----------[0] 是否为1473域
    -----------[0] 是否为主域
    */
    isDomain: function (URL) {
        var _url;
        //用本地html打开网站时，没有window.location。
        if (window.location) {
            //获取当前域名地址栏，不包含目录结构。例如：
            _url = window.location.protocol + "//" + window.location.host; //当前域
            if (_url.indexOf("1473.cn") > -1 && URL.indexOf("1473.cn") > 0) {
                return [true, !URL.indexOf(_url)];
            } else {
                return [false, false];
            }
            // return [(_url.indexOf("1473.cn") > -1 && URL.indexOf("1473.cn") > 0), !URL.indexOf(_url)];
        }
        // else { return [false, false]; }
    },

    /**
    * 创建Ajax对象
    *
    * @param  {url} 连接地址
    * @returns {object} ajax对象
    */
    CA: function (url) {
        var i, _ajax, _xhr, _url, _ajaxObj = U.A.ASet,
            _preAjax = _ajaxObj[_ajaxObj.length - 1],
            _xhr = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"]; //ajax对象
        // 获取当前域名
        if (window.location) {
            _thisUrl = window.location.protocol + "//" + window.location.host;
        } else {
            _thisUrl = "";
        }
        //获取可以使用的Ajax对象
        for (i = 0; i < _ajaxObj.length; i++) { //在ajax里找到使用对象
            if ((_ajax = _ajaxObj[i].systemAjax).readyState == 4) {
                _ajax.onreadystatechange = U.M.apply(); //设置回调为空
                _ajax.abort(); //停止
                return _ajaxObj[i];
            }
        }
        //这里创建Ajax对象
        try { _ajax = new window.XMLHttpRequest(); } //浏览器默认ajax对象
        catch (e) {
            for (i = 0; i < _xhr.length; i++) { //ie6-系列使用
                try {
                    _ajax = new ActiveXObject(_xhr[i]);
                    break;
                } catch (e) { }
            }
        }
        //h5创建跨域ajax
        if (url.indexOf(_thisUrl) == -1 && window.XDomainRequest) {
            _ajax = new window.XDomainRequest();
        }
        //疑似非法ajax请求次数记录
        var timeSpan;
        //如果当前发送的ajax请求和上一次发送的ajax请求时间小于0.05秒。则判断为循环非法操作。
        if (_preAjax && ((new Date().getTime() - _preAjax.date) < 50)) {
            timeSpan = _preAjax.timeSpan + 1; //恶意攻击+1.
        } else {
            if (_preAjax) {
                timeSpan = _preAjax.timeSpan;
            } else {
                timeSpan = 0;
            }
        }
        //(_preAjax && ((new Date().getTime() - _preAjax.D) < 50)) ? _preAjax.J + 1 : _preAjax ? _preAjax.J : 0;
        //生成ajax请求
        var ajax = {
            systemAjax: _ajax, //系统ajax  new window.XMLHttpRequest();  //systemajax
            date: this.UTI, //当前时间 new Date();    //date
            fun: this.url, //向后台发送请求的函数名称。  //fun
            timeSpan: timeSpan //与上一次发送Ajax请求的时间差距。  //timespan
        };
        _ajaxObj.push(ajax); //把这次的ajax请求记录到数组，目的是方便以后获取查询过的ajax。1、为了找错误，2、为了判断ajax的时间差，防止恶意用户用循环向服务器不断发送请求，导致服务器瘫痪。
        //return (_UDE[_UDE.length] = { TO: _UAE, D: this.UTI, N: this.UFN, J: (_UOE && ((new Date().getTime() - _UOE.D) < 50)) ? _UOE.J + 1 : _UOE ? _UOE.J : 0 });
        return ajax;
    },

    //设置异步请求
    async: function () {
        var _ajax = this.ajax.systemAjax, //ajax对象
            _loading = this.cbParams, //回调参数 loading
            _isUndefined = U.Ut.isUndefined(_ajax.onload), //判断兼容问题
            _cb;
        if (_isUndefined) {
            _cb = U.M.apply(this, this.AE); //回调函数设置
        }
        else {
            _cb = U.M.apply(this, this.TAC); //回调函数设置
        }
        // _cb = U.M.apply(this, this[_isUndefined ? "AE" : "TAC"]); //回调函数设置
        // 设置loading
        if (_loading && _loading[0]) {
            if (_loading[0][0]) {
                U.MD.loading(_loading[0][0], _loading[0][1]);
            } else {
                U.MD.loading(_loading[0], _loading[0][1]);
            }
        }
        // (_cbParams && _cbParams[0]) && (U.MD.loading(_cbParams[0][0] || _cbParams[0], _cbParams[0][1]));
        //设置错误和异步请求
        // 设置ajax回调函数
        if (_isUndefined) {
            _ajax.onreadystatechange = _cb;
        } else {
            _ajax.onload = _cb;
        }
        // 设置ajax错误时的处理
        try {
            _ajax.onerror = U.M.apply(this, this.OER);
        } catch (e) { }
    },
    //跨域异步使用 
    TAC: function () {
        this.ajax.systemAjax.status = 200; //设置成功状态
        this.AE(true); //调用跨域统一处理
    },
    //错误处理
    OER: function () {
        this.ajax.systemAjax.status = 500; //设置错误为500
        this.AE(true); //错误处理
    },
    /**
    * 服务器异步加载成功后，得到返回值，取消loading,然后回调.
    *
    * @param  {boolean} 是否可以直接通过 不进行ajax流程判断
    * @param  {string} 绕过ajax流程 传参
    */
    AE: function (UTF, UST) {
        try {
            if (UTF === true || this.ajax.systemAjax.readyState == 4) { //已经加载成功
                (this.ajax) && (this.ajax.timeSpan = 0);
                var _loading = this.cbParams, //loading 元素
                    _data = this.sync(UST), //ajax string 数据 生成 json数据集
                    _timeSpan = (new Date()).getTime() - this.UTI.getTime(); //ajax总共耗时
                // 取消loading
                if (_loading && _loading[0]) {
                    if (_loading[0][0]) {
                        U.MD.uploading(_loading[0][0]);
                    } else {
                        U.MD.uploading(_loading[0]);
                    }
                }
                // (_UPE && _UPE[0]) && (U.MD.uploading(_UPE[0][0] || _UPE[0])); //取消loading
                //访问时间太长或者出现了错误 输出控制台
                if (_timeSpan > 1000 || _data.error) {
                    (U.M.Console({ "T": _timeSpan, "N": this.url, "V": _data.error }));
                }
                // (_timeSpan > 1000 || _data.error) && (U.M.Console({ "T": _timeSpan, "N": this.url, "V": _data.error })); //访问时间太长或者出现了错误 输出控制台
                //关闭连接
                if (_data.httpRequest.abort) {
                    _data.httpRequest.abort();
                }
                // (_data.r.abort) && (_data.r.abort()); //关闭连接
                //回调数据
                if (this.cb && _data.value !== null) {
                    this.cb.call(this.win, _data)
                }
                // (this.cb && _data.value !== null) && (this.cb.call(this.win, _data)); //回调数据
            }
        } catch (e) { U.M.Console(e); }
    },

    /**
    * 生成数据
    *
    * @param  {string} 绕过ajax流程 传参
    * @return  {string} 数据参数
    */
    sync: function (data) {
        var _UTF, _ajax;
        //获取ajajx对象
        if (this.ajax) {
            _ajax = this.ajax.systemAjax;
        }
        else {
            _ajax = {};
        }
        // _URE = this.ajax ? this.ajax.systemAjax : {}, //获取ajajx对象
        var _ajaxAttr = { httpRequest: _ajax, status: null, value: null, context: this.cbParams }, //ajax对象使用
            _errorFun = U.A.Error(); //ajax错误处理
        //没有值 直接设置报错
        //        if (!_ajaxAttr.httpRequest) {
        //            _ajaxAttr.httpRequest = { status: "504", statusText: "Gateway timeout" };
        //        }
        // (!_ajaxAttr.r) && (_ajaxAttr.r = { status: "504", statusText: "Gateway timeout" }); //没有值 直接设置报错
        _ajaxAttr.value = data; //设置值
        //请求成功处理
        if (_ajax.status == 200) {
            _ajaxAttr.value = this.getBackStrToJson(); //生成返回的参数
            _UTF = _errorFun.isError(_ajaxAttr.value);
            if (_UTF) {
                _errorFun.set(_ajaxAttr.value);
            }
        }
        //错误处理.
        else {
            _ajaxAttr.status = {
                "status": _ajax.status,
                "statusText": _ajax.statusText
            };
        }
        //        if (_ajaxAttr.error && this.err) {
        //            this.err()
        //        } else if (_UTF && this.err) {
        //            this.err()
        //        }
        // ((_ajaxAttr.error || _UTF) && this.err) && (this.err());
        return _ajaxAttr; //生成数据返回
    },

    /**
    * 得到后台返回的字符串，再把后台返回的字符串生成一个json对象
    *
    * @return  {object} json值
    */
    getBackStrToJson: function () {
        var _ajax = this.ajax.systemAjax, //ajax对象
            _resXml = _ajax.responseXML; //xml对象
        //如果服务器返回的为xml对象
        if (_resXml) {
            _resXml = _resXml.xml
        }
        // (_resXml) && (_resXml = _resXml.xml); //如果服务器返回的为xml对象
        if (!_resXml) {
            _resXml = _ajax.responseText; //返回的值
            _resXml = U.M.toList(_resXml); //生成对象
        }
        return _resXml;
    }
}

//#endregion

//#region jsonp跨域获取数据,1473的项目跨域到百度，只能通过js方式进行跨域。js引用百度的一个js，百度返回一个值。就可以跨域了。

/**
* jsonp跨域获取数据初始化
*
* @param  {object} jsonp参数
----------[call] 回调函数
----------[parameter] 回调参数
* @return  {string} jsonp类对象
*/
U.A.Jsonp = $.Jsonp = function (UDE) {
    var _UTE = new U.A.Jsonp.init(UDE); //初始化jsonp类
    _UTE.send(); //发送请求
    return _UTE;
}

/**
* jsonp初始化对象
*
* @param  {object} jsonp参数
----------[call] 回调函数
----------[parameter] 回调参数
*/
U.A.Jsonp.init = function (UDE) { //初始化Jsonp对象
    U.Ut.AddObj(this, UDE);
}

U.A.Jsonp.init.prototype = {
    /**
    * jsonp发送请求数据
    *
    */
    send: function () {
        var _URL = this.url, //发送的地址
            _UCE = this.call, //发送的回调函数
            _UPE = this.parameter, //发送的参数
            UDID = U.M.getFun(U.M.apply(this, this.success)).id; //设置委托状态 等待回调
        this.UFE = U.MD.DynamicLoad(_URL + (_UCE ? "?callback=" + _UDID + "&" : "") + (_UPE ? "parameter=" + U.M.SplitArray(_UPE) : ""), "js", U.M.apply(this, this.Asyn), null, true); //请求数据等待回调
    },

    //异步加载成功
    Asyn: function () { },

    /**
    * jsonp异步回调
    *
    */
    success: function (r) {
        (this.call) && (this.call(r)); //执行回调函数
        $(this.UFE).remove(); //删除遗留的jsonp数据文件
    }
}


//#endregion

//#region ajax post请求

/**
* post请求
* @param  {object} 传参
----------[url] 请求的地址
----------[parameter] 请求的参数
----------[context] 请求的回调参数
----------[cb] 回调函数
* @return  {object} post对象
*/
U.A.Post = $.Post = function (UDE) {
    var _UTE = new U.A.Post.init(UDE); //初始化对象
    _UTE.send(); //发送请求
    return _UTE;
}

/**
* 初始化post对象
*
*/
U.A.Post.init = function (UDE) {
    U.Ut.AddObj(this, UDE);
}

U.A.Post.init.prototype = {
    //发送请求
    send: function () {
        var i, _UDE = [],
            _URL = this.url, //请求的地址
            _UPE = this.parameter, //请求参数
            _UCE = this.context; //请求传参
        //添加参数
        if (_UPE) {
            for (i in _UPE) {
                if (_UPE.hasOwnProperty(i)) {
                    _UDE.push($$("input", { "name": i, "value": _UPE[i] }));
                }
            }
        }
        //发送消息
        U.UP.uploading(_UDE, U.M.apply(this, this.success), _UCE, _URL, null, "application/x-www-form-urlencoded");
    },
    /**
    * psot请求成功回调
    * @param  {object} 数据
    */
    success: function (UDE) { //异步回调
        (this.cb) && (this.cb(UDE));
    }
}

//#endregion



//#endregion

//#region 错误区域,需要在界面中显示，如何显示，先设计，后制作功能。然后重写一个函数，不需要类。

//错误区域初始化
U.A.Error = function () {
    return new U.A.Error.init();
}

//生成错误对象 错误对象的实例
U.A.Error.init = function () {
    this.State = this.LogID = this.Value = this.Dt = this.Type = null;
}

U.A.Error.init.prototype = {
    /**
    * 判断对象是否为错误对象
    *
    * @return  {object} json值
    */
    isError: function (UDE) {
        if (U.Ut.isObject(UDE)) { //判断是否为对象
            for (var i in this) { if (this.hasOwnProperty(i) && !(i in UDE)) { return false; } }
            return true;
        }
        return false;
    },

    /**
    * 设置错误
    *
    * @return  {object} 错误值
    */
    set: function (UDE) {
        U.Ut.AddObj(this, UDE); //根据错误值添加错误
        return this;
    }
}

//#endregion